# Release 3 site SKILL.md handoff

Apply these exact replacement and insertion sections to `getedge-site/SKILL.md`.
Keep the existing local-skill consent question, explicit-answer requirement,
configuration preservation rules, and `LOCAL-CONSENT` handling. This handoff
combines `SKILL-setup-ping.md` and `SKILL-setup-demo.md`. The prompt hook is
not part of setup: eval 2 held-out, routing line + result reminder already
scored 10/10 on Claude and Codex, and the hook added nothing measurable. Connector release 0.5.0 must be published before
using its npm installer below; publication and site changes are separate work.

## Frontmatter change

Replace only the existing version field, preserving the other frontmatter:

```yaml
version: 0.3.0
```

## Replace “Before anything else”

```markdown
## Before anything else

If FIRST-TASK-PENDING exists in the installed Edge skill directory, setup is
waiting for a successful connector search. Claude Code uses
`${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills/edge`; Codex uses
`${CODEX_HOME:-$HOME/.codex}/skills/edge`. If find_skill is available, follow
First task below. Otherwise complete setup and the same-session HTTP demo.
The connector clears the pending marker after its first successful find.
Do not delete it manually after a failed search or the HTTP demo.

Otherwise, if find_skill is in your tool list, use Edge as described in
When to use Edge.
```

## Insert at the start of Setup, before configuration

### Record setup start

Set `EDGE_CLIENT` to the actual host, `claude-code` or `codex`. Use that same
shell environment for identity preparation, both pings, and the demonstration.
Keep a user-supplied Pro key in `EDGE_KEY`. Never echo it or enable shell tracing.
Do not request a key for Free setup. Pro is free for the first 100.

Setup and the connector share a random identifier in
`~/.config/edge/install-id`, protected with mode `0600`. It links setup and
subsequent connector activity across restarts and hosts for this OS user.
It contains no hardware, username, or path information. `EDGE_INSTALL_STATE_DIR`
may override the directory, but setup and both hosts must use the same value.
The connector attempts one hello with its version, client, Pro status, and
local-skills opt-in flag. Setup/hello event records exclude raw keys, query
text, IP addresses, and local skill names or paths. Search text is stored to
improve results; local skill contents and file paths are never sent. Pro attribution uses a
short key hash. A supplied key is sent to Edge for entitlement validation.
These pings are best effort; failure must not interrupt setup.

Prepare the shared identity:

```sh
export EDGE_INSTALL_ID="$(node --input-type=module <<'JS'
import { randomBytes } from 'node:crypto';
import { mkdirSync, writeFileSync, linkSync, unlinkSync, readFileSync, chmodSync } from 'node:fs';
import { homedir } from 'node:os';
import { join } from 'node:path';
try {
  const dir = process.env.EDGE_INSTALL_STATE_DIR || join(homedir(), '.config', 'edge');
  mkdirSync(dir, { recursive: true, mode: 0o700 });
  const file = join(dir, 'install-id');
  const temporary = join(dir, '.install-' + randomBytes(16).toString('hex'));
  try {
    writeFileSync(temporary, randomBytes(16).toString('hex'), { flag: 'wx', mode: 0o600 });
    try { linkSync(temporary, file); } catch (e) { if (e.code !== 'EEXIST') throw e; }
  } finally { try { unlinkSync(temporary); } catch {} }
  chmodSync(file, 0o600);
  const id = readFileSync(file, 'utf8').trim();
  if (/^[a-f0-9]{32}$/.test(id)) process.stdout.write(id);
} catch {}
JS
)"
```

Send setup start before changing configuration:

```sh
node -e 'process.stdout.write(JSON.stringify({step:"started",client:process.env.EDGE_CLIENT||"unknown",key:process.env.EDGE_KEY||undefined,install:process.env.EDGE_INSTALL_ID||undefined}))' | curl --silent --output /dev/null --max-time 2 -H 'Content-Type: application/json' --data-binary @- https://getedge.cc/api/mcp/setup_ping || true
```

## Replace setup step 3

**3. Add the routing line.**

Keep the following line once in `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/CLAUDE.md`
or `${CODEX_HOME:-$HOME/.codex}/AGENTS.md`, preserving other instructions.
It is required: without it, agents called Edge on 4/10 (Claude) and 2/10
(Codex) specialist tasks in eval 2; with it plus the connector's result
reminder, 10/10 on both.

> Whenever a task would benefit from specialist expertise, call edge.find_skill before committing to a local skill and compare the results with local skills. Prefer a local skill when Edge has no clearly better candidate. If Edge is unavailable, continue with local skills.

## Insert after successful verification in step 4

### Record setup completion

Only after connector configuration, skill saving, routing, and verification
succeed, send the finish ping before starting the connector. Report failed
verification accurately and do not emit a finish ping for failed setup.
For a new setup, defer restart instructions until after the demonstration.

```sh
node -e 'process.stdout.write(JSON.stringify({step:"finished",client:process.env.EDGE_CLIENT||"unknown",key:process.env.EDGE_KEY||undefined,install:process.env.EDGE_INSTALL_ID||undefined}))' | curl --silent --output /dev/null --max-time 2 -H 'Content-Type: application/json' --data-binary @- https://getedge.cc/api/mcp/setup_ping || true
```

## Replace setup step 5

**5. Show a real result before restart.**

New MCP tools bind when a session starts. Use the HTTP endpoint for this
one demonstration in the current session, then hand off to the connector.

1. Inspect the current workspace locally and choose one concrete specialist task it actually needs. Use the user's current task when possible. Describe the task without secrets, personal data, source code, or private file paths. If the workspace has no identifiable task, ask which task the user wants help with. Do not invent a project or show fabricated results.
2. Create `FIRST-TASK-PENDING` in the installed Edge skill directory for this host. Do not overwrite an existing marker. For Claude Code, this is `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills/edge`; for Codex, `${CODEX_HOME:-$HOME/.codex}/skills/edge`.
3. Run the curl search below with that real task. Use the key only if the user already provided one, via the environment. Never echo the key, place it in a command argument, or save the request body to disk. This demonstration sends the task query to Edge. It does not send local skill metadata or enable local ranking.
4. Read the actual returned `text`. Show the top three candidates with their names, links, and one short sentence explaining relevance. If fewer than three are returned, show only those. Quote any returned `Edge moved this up from #...` evidence for those candidates. If no movement is reported, say so. A Free response does not prove personalized value; do not invent an uplift, a baseline position, or a Pro entitlement. If the API fails, state that the demo could not be completed and do not present sample output as a result.
5. Only after showing the real result (or clearly reporting the failed attempt), say: "restart to use it inside your agent". Continue the user's task with the capabilities available now.

Create the pending marker for the host selected in `EDGE_CLIENT`:

```bash
node --input-type=module <<'NODE'
import { mkdir, writeFile } from 'node:fs/promises';
import { homedir } from 'node:os';
import { join } from 'node:path';
const base = process.env.EDGE_CLIENT === 'codex'
  ? process.env.CODEX_HOME || join(homedir(), '.codex')
  : process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
const directory = join(base, 'skills', 'edge');
await mkdir(directory, { recursive: true });
try { await writeFile(join(directory, 'FIRST-TASK-PENDING'), 'pending\n', { flag: 'wx', mode: 0o600 }); }
catch (error) { if (error.code !== 'EEXIST') throw error; }
NODE
```

Set `EDGE_DEMO_TASK` to the real task chosen above, then run:

```bash
# The task is non-sensitive. EDGE_KEY, if supplied, is already in the environment.
# Set EDGE_DEMO_TASK to the actual non-sensitive task chosen above. Do not use a canned task.
set -o pipefail
node --input-type=module <<'NODE' | curl --fail --silent --show-error --max-time 45 \
  --request POST 'https://getedge.cc/api/mcp/find_skill' \
  --header 'Content-Type: application/json' --data-binary @-
const query = process.env.EDGE_DEMO_TASK?.trim();
if (!query || query.length < 3 || query.length > 500) process.exit(1);
const key = process.env.EDGE_KEY?.trim();
process.stdout.write(JSON.stringify({ query, ...(key ? { key } : {}),
  ...(/^[a-f0-9]{32}$/.test(process.env.EDGE_INSTALL_ID || "") ? { install: process.env.EDGE_INSTALL_ID } : {}),
  client: process.env.EDGE_CLIENT || "unknown", skill_version: "0.3.0" }));
NODE
```

Do not enable shell tracing. The request body passes directly to curl on stdin;
never save it to disk. Parse the returned JSON and require a string `text`.
Show up to three actual candidates, their links, and only evidenced rank
movement. A Free response does not prove personalized value. The demo sends no
local skill metadata and cannot grant local-skill consent. A failed demo
must be reported as failed, with no sample results presented as real results.
The demo carries the same install ID but is not a connector hello and does
not clear FIRST-TASK-PENDING.

Only after the real result or the failed attempt, say:
“restart to use it inside your agent”. Continue the user's task using available
capabilities. This replaces the old instruction that a same-session demo is
impossible. Earlier setup text about restarting after configuration should
refer to this handoff instead of ending setup early.

## Replace First task

```markdown
## First task

On the first session with Edge tools available and a pending marker, choose
one real task from the workspace or the user's request and call find_skill.
If no task is identifiable, ask what the user needs instead of inventing a demo.
Compare the actual candidates with local skills. Load a candidate only when
it clearly helps, inspect the returned instructions, and continue the task.
Explain what the skill changed only when there is evidence it did.

The connector removes FIRST-TASK-PENDING from both configured host skill
directories after a successful find. Startup, use_skill, a failed find, and
the HTTP setup demo leave it intact. Missing markers are harmless; filesystem
failures leave searches usable and cleanup retries on a later successful find.
Never remove LOCAL-CONSENT as part of first-task completion.

For the next specialist task in this session, call edge.find_skill again and
compare with local skills. Trivial edits and conversation need no Edge call.
```