@opsee/cli 0.11.9 → 0.11.11

package/README.md

@@ -271,7 +271,7 @@ node bin/opsee.js foreman pause 17              # no new dispatch in the Run; in
 node bin/opsee.js foreman resume 17
 node bin/opsee.js foreman cancel 1436           # stop the Worker; the attempt is recorded as cancelled
 node bin/opsee.js foreman plan 17               # an attended planning session on the Initiative, its context as the first message
-node bin/opsee.js foreman plan 17 --account work --skill wayfinder
+node bin/opsee.js foreman plan 17 --account work --skill initiative-map
 ```
 
 ### Slots: how many run at once, and in what order
@@ -1651,7 +1651,7 @@ second RPC that has to agree with the first about which ids exist.
 
 ### Planning sessions: `foreman plan`
 
-`opsee foreman plan <initiativeId> [--account <name>] [--skill <to-issues|wayfinder|to-spec>] [--memory <n>]`
+`opsee foreman plan <initiativeId> [--account <name>] [--skill <initiative-decompose|initiative-map|initiative-spec>] [--memory <n>]`
 (story 10, `src/commands/foreman-plan.ts`) opens an attended session that starts already knowing
 last night's results. It is attended only: nothing in it launches or resumes a Worker turn, and
 the session is never resumed unattended. Git in that session is the human's own, outside the
@@ -1669,7 +1669,7 @@ for Claude Code, `.agents/skills/<skill>/SKILL.md` for Codex; `opsee init` write
 command never writes it, since the worktree is the human's to commit from, and a checkout without
 it is refused before the Tracker or git is touched, with the line that fixes it (run `opsee init`,
 commit, merge); a skill in the checkout but not yet on origin's default branch is refused after
-the Workspace is made, with the command that removes it. The default skill is `to-issues`.
+the Workspace is made, with the command that removes it. The default skill is `initiative-decompose`.
 
 The context (`assemblePlanContext`, `core/plan-context.ts`) is Context Assembly turned to the
 Initiative, read through the Tracker Adapter's `getInitiativeContext` (the backend's
@@ -1734,8 +1734,8 @@ integration tier (`src/foreman/__tests__/opsee-tracker-adapter.integration.test.
 real backend. The check with a real vendor stays manual: on the Foreman Initiative after a
 scratch Run, `foreman plan 17 --account <name>`; confirm the terminal's `context:` lines count
 the Completion Reports and Claude Code (or Codex) opens in the new worktree with the context and
-"Start by running the /to-issues skill against Initiative 17" as the first message and the prior
-Completion Reports listed under "## Completion Reports"; run `/to-issues` on a small addition and
+"Start by running the /initiative-decompose skill against Initiative 17" as the first message and the prior
+Completion Reports listed under "## Completion Reports"; run `/initiative-decompose` on a small addition and
 confirm the Tasks it files appear in Initiative 17 with `## Goal`, `## Acceptance Criteria`,
 `## Verification` and `## Boundaries`; leave, and confirm the closing line names the worktree and
 its removal.
@@ -1854,7 +1854,7 @@ the fake code host and the two Tasks' boards and labels through the raw RPCs.
 After a change to `init`, in a scratch git repo:
 
 1. Run `node <path>/cli/bin/opsee.js init --project <key>`; it must list what it created and end
-   with the counts line. Start Claude Code there: `/wayfinder`, `/to-spec` and `/to-issues` must
+   with the counts line. Start Claude Code there: `/initiative-map`, `/initiative-spec` and `/initiative-decompose` must
    be offered and the `opsee` MCP server must connect (OAuth on first use). Codex must show the same
    three skills and the server from `.codex/config.toml`.
 2. Run it again; every line must read `unchanged`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opsee/cli",
-  "version": "0.11.9",
+  "version": "0.11.11",
   "description": "Opsee CLI — the opsee binary: login, whoami, and the home of the Foreman",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
     "@bufbuild/protobuf": "^2.14.0",
     "@connectrpc/connect": "^2.1.2",
     "@connectrpc/connect-node": "^2.1.2",
-    "@opsee/mcp-server": "0.11.9",
+    "@opsee/mcp-server": "0.11.11",
     "tsx": "^4.23.12"
   },
   "devDependencies": {

package/skills/README.md

@@ -1,3 +1,3 @@
 # Planning skills
 
-Opsee-owned forks of Matt Pocock's `wayfinder`, `to-spec`, and `to-issues` skills (https://github.com/mattpocock/skills, MIT; attribution kept in each `SKILL.md`), changed only where Opsee requires it: they read the per-repo tracker doc `docs/agents/issue-tracker.md`, publish through the `opsee_*` MCP tools into an Initiative, and write the Foreman work contract (Goal, Acceptance Criteria, Verification, Boundaries) into every Task description, with blocking as TaskDependency edges and `ready-for-agent` as the dispatch label. Opsee owns these copies because the work contract is the product's opinion (ADR-0011); `opsee init` copies each folder into the repo's `.claude/skills/` and `.agents/skills/` alongside the tracker doc, and the Codex `agents/openai.yaml` beside each `SKILL.md` is what Codex reads. Edit them here, never in a consuming repo. The tracker doc they read is rendered from `../templates/issue-tracker.md`; `src/__tests__/skills.test.ts` checks the skills and the template stay in step (section names, the Wayfinding operations the wayfinder fork quotes).
+Opsee-owned forks of Matt Pocock's `wayfinder`, `to-spec`, and `to-issues` skills, shipped under Opsee's own names (`initiative-map`, `initiative-spec`, `initiative-decompose`) so a repo full of skills groups them by what they act on (https://github.com/mattpocock/skills, MIT; attribution kept in each `SKILL.md`), changed only where Opsee requires it: they read the per-repo tracker doc `docs/agents/issue-tracker.md`, publish through the `opsee_*` MCP tools into an Initiative, and write the Foreman work contract (Goal, Acceptance Criteria, Verification, Boundaries) into every Task description, with blocking as TaskDependency edges and `ready-for-agent` as the dispatch label. Opsee owns these copies because the work contract is the product's opinion (ADR-0011); `opsee init` copies each folder into the repo's `.claude/skills/` and `.agents/skills/` alongside the tracker doc, and the Codex `agents/openai.yaml` beside each `SKILL.md` is what Codex reads. Edit them here, never in a consuming repo. The tracker doc they read is rendered from `../templates/issue-tracker.md`; `src/__tests__/skills.test.ts` checks the skills and the template stay in step (section names, the Wayfinding operations the wayfinder fork quotes).

package/skills/{to-issues → initiative-decompose}/SKILL.md

@@ -1,17 +1,17 @@
 ---
-name: to-issues
+name: initiative-decompose
 description: Break a plan, spec, or PRD into independently-grabbable Tasks inside an Opsee Initiative using tracer-bullet vertical slices, each carrying the Foreman work contract. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues.
 ---
 
 # To Issues
 
-> Forked from the `to-issues` skill by Matt Pocock (https://github.com/mattpocock/skills, MIT). This copy is owned by Opsee: the process is upstream's, the tracker is Opsee and every issue carries the Foreman work contract.
+> Forked from the `to-issues` skill by Matt Pocock (https://github.com/mattpocock/skills, MIT). Renamed `to-issues` -> `initiative-decompose` for Opsee's vocabulary; the attribution is to the original. This copy is owned by Opsee: the process is upstream's, the tracker is Opsee and every issue carries the Foreman work contract.
 
 Break a plan into independently-grabbable issues using vertical slices (tracer bullets).
 
 The issue tracker is Opsee, described in `docs/agents/issue-tracker.md` at the repo root; `opsee init` writes that file. Publishing goes through the `opsee_*` MCP tools. If the doc is missing, stop and ask the user to run `opsee init`; if the tools are missing, stop and ask the user to attach the Opsee MCP server (`/mcp`). Do neither yourself, and publish nothing until both are present. In the doc, "issue" means an Opsee **Task**, and every issue lives inside an **Initiative**.
 
-Read the doc's "Work contract" and `/to-issues` sections before step 5.
+Read the doc's "Work contract" and `/initiative-decompose` sections before step 5.
 
 ## Process
 
@@ -55,10 +55,10 @@ Iterate until the user approves the breakdown.
 
 ### 5. Publish the issues to Opsee
 
-Slices become **Tasks inside the Initiative** that holds the plan; a spec published by `/to-spec` already is one, and a bare plan gets one first (`status: "draft"`, the plan as its core idea, as the tracker doc's `/to-spec` hook describes). Each Task's description is the issue body template below. Publish the whole approved breakdown in one call, following the tracker doc's `/to-issues` hook for the exact arguments:
+Slices become **Tasks inside the Initiative** that holds the plan; a spec published by `/initiative-spec` already is one, and a bare plan gets one first (`status: "draft"`, the plan as its core idea, as the tracker doc's `/initiative-spec` hook describes). Each Task's description is the issue body template below. Publish the whole approved breakdown in one call, following the tracker doc's `/initiative-decompose` hook for the exact arguments:
 
 - An Initiative with **no Tasks yet**: `opsee_decompose_initiative`, every slice as an entry with a temporary `ref` and the blocking edges between `ref`s. This also moves a `draft` Initiative to `active`.
-- An Initiative that **already has Tasks** (re-planning, or a `/wayfinder` map that has become executable): `opsee_reconcile_initiative`, kept Tasks tagged with `existingTaskId` and new ones without. Run it with `dryRun: true` first, show the human the changeset, and only after their approval run it for real. Keep a map's closed wayfinder tickets so the record of the route survives; Tasks that carry execution state are never deleted by reconcile, and the human decides their fate.
+- An Initiative that **already has Tasks** (re-planning, or a map that has become executable): `opsee_reconcile_initiative`, kept Tasks tagged with `existingTaskId` and new ones without. Run it with `dryRun: true` first, show the human the changeset, and only after their approval run it for real. Keep a map's closed wayfinder tickets so the record of the route survives; Tasks that carry execution state are never deleted by reconcile, and the human decides their fate.
 
 **Blocked by** is a `BLOCKS` TaskDependency edge from blocker to blocked, never a line in the body; an absent edge is the absence of a blocker.
 
@@ -90,3 +90,12 @@ Optional: files or areas a Worker must not touch. Omit the section if none.
 The headings are the Foreman's work contract (`cli/CONTEXT.md`): a `ready-for-agent` Task that lacks them is not dispatched but sent to a Triage turn, so write them in full. Acceptance Criteria go in the description as `- [ ]` checkboxes, not through `opsee_add_acceptance_criterion`. A Task that descends from another Task gets `parentTaskId`; there is no Parent section in the body.
 
 Do NOT close or modify the Initiative or any parent Task.
+
+### 6. Say where the work went, and what can start now
+
+Finish by reporting the Initiative's **link in Opsee** (the tracker doc's `/initiative-decompose` hook prints the URL shape), how many Tasks were filed, and how many carry `ready-for-agent`. Then name both ways forward — `ready-for-agent` means nothing to a human who does not know what reads it:
+
+- **Unattended:** `opsee foreman run <initiativeId>` takes those Tasks one at a time, each in its own workspace and branch, opening a draft MR per Task and writing what happened back into the Initiative's memory. It needs the Foreman set up on their machine first (`opsee foreman account add`); if it is not, say so rather than assuming.
+- **By hand:** they are ordinary issues. Work them in this session or any other. The Initiative is the record either way.
+
+Do not run the Foreman yourself, and do not offer to: it dispatches unattended Workers against the user's own subscription on their machine, which is theirs to start.

package/skills/initiative-decompose/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Decompose Initiative (Opsee)"
+  short_description: "Split a plan into tracer-bullet Tasks inside an Opsee Initiative"
+policy:
+  allow_implicit_invocation: false

package/skills/{wayfinder → initiative-map}/SKILL.md

@@ -1,10 +1,10 @@
 ---
-name: wayfinder
+name: initiative-map
 description: Plan a huge chunk of work — more than one agent session can hold — as a shared map of decision tickets in Opsee, and resolve them one at a time until the way to the destination is clear.
 disable-model-invocation: true
 ---
 
-> Forked from the `wayfinder` skill by Matt Pocock (https://github.com/mattpocock/skills, MIT). This copy is owned by Opsee: the process is upstream's, the tracker is Opsee.
+> Forked from the `wayfinder` skill by Matt Pocock (https://github.com/mattpocock/skills, MIT). Renamed `wayfinder` -> `initiative-map` for Opsee's vocabulary; the attribution is to the original. This copy is owned by Opsee: the process is upstream's, the tracker is Opsee.
 
 A loose idea has arrived — too big for one agent session, and wrapped in fog: the way from here to the **destination** isn't visible yet. Wayfinding is about finding that way, not charging at the destination. This skill charts the way as a **shared map** on the repo's issue tracker, then works its **decision tickets** — questions whose resolution is a decision, not slices of a build to execute — one at a time until the route is clear.
 
@@ -135,4 +135,4 @@ User invokes with a map (its title, `OPS-nnn`, or the Initiative). A ticket is *
 
 The user may run unblocked tickets in parallel, so expect other sessions to be editing the tracker concurrently.
 
-When the map has no open tickets, the way is clear: hand off to `/to-issues` against the same Initiative, as the tracker doc's "Graduate to execution" describes, so the route's decisions stay in the memory the execution Tasks are read against.
+When the map has no open tickets, the way is clear: hand off to `/initiative-decompose` against the same Initiative, as the tracker doc's "Graduate to execution" describes, so the route's decisions stay in the memory the execution Tasks are read against. Report the map's Initiative by **link in Opsee**, not by id alone — the route you charted is the thing the user will want to reread, and it lives there now.

package/skills/initiative-map/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Map an Initiative (Opsee)"
+  short_description: "Chart a foggy Initiative as decision tickets and resolve them one at a time"
+policy:
+  allow_implicit_invocation: false

package/skills/{to-spec → initiative-spec}/SKILL.md

@@ -1,16 +1,16 @@
 ---
-name: to-spec
+name: initiative-spec
 description: Turn the current conversation into a spec and publish it to Opsee as a draft Initiative — no interview, just synthesis of what you've already discussed.
 disable-model-invocation: true
 ---
 
-> Forked from the `to-spec` skill by Matt Pocock (https://github.com/mattpocock/skills, MIT). This copy is owned by Opsee: the process is upstream's, the tracker is Opsee.
+> Forked from the `to-spec` skill by Matt Pocock (https://github.com/mattpocock/skills, MIT). Renamed `to-spec` -> `initiative-spec` for Opsee's vocabulary; the attribution is to the original. This copy is owned by Opsee: the process is upstream's, the tracker is Opsee.
 
 This skill takes the current conversation context and codebase understanding and produces a spec. Do NOT interview the user — just synthesize what you already know.
 
 The issue tracker is Opsee, described in `docs/agents/issue-tracker.md` at the repo root; `opsee init` writes that file. Publishing goes through the `opsee_*` MCP tools. If the doc is missing, stop and ask the user to run `opsee init`; if the tools are missing, stop and ask the user to attach the Opsee MCP server (`/mcp`). Do neither yourself, and publish nothing until both are present. In the doc, "issue" means an Opsee **Task**, and every issue lives inside an **Initiative**.
 
-Read the doc's `/to-spec` hook before step 3.
+Read the doc's `/initiative-spec` hook before step 3.
 
 ## Process
 
@@ -20,7 +20,7 @@ Read the doc's `/to-spec` hook before step 3.
 
 Check with the user that these seams match their expectations.
 
-3. Write the spec using the template below, then publish it to Opsee as an **Initiative**, not a Task: `opsee_create_initiative` with the spec title, a one- or two-line `summary`, `status: "draft"`, and the full spec body as the `coreIdea` in markdown. If the spec was written from a repo file, name the file path in the summary so the two stay linked. Do **not** apply a triage label: labels are Task-level in Opsee, and the spec's readiness is recorded by `/to-issues` when it files the Tasks and labels them `ready-for-agent`. Report the Initiative by title and id.
+3. Write the spec using the template below, then publish it to Opsee as an **Initiative**, not a Task: `opsee_create_initiative` with the spec title, a one- or two-line `summary`, `status: "draft"`, and the full spec body as the `coreIdea` in markdown. If the spec was written from a repo file, name the file path in the summary so the two stay linked. Do **not** apply a triage label: labels are Task-level in Opsee, and the spec's readiness is recorded by `/initiative-decompose` when it files the Tasks and labels them `ready-for-agent`. Report the Initiative by title, id and **its link in Opsee** (the tracker doc's `/initiative-spec` hook prints the URL shape), and say what it is waiting for: a breakdown with `/initiative-decompose` against this same Initiative. The spec now lives in Opsee rather than in this conversation, and a person who cannot open it will not read it.
 
 <spec-template>
 

package/skills/initiative-spec/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Spec an Initiative (Opsee)"
+  short_description: "Turn this conversation into a spec, published as an Opsee Initiative"
+policy:
+  allow_implicit_invocation: false

package/src/args.ts

@@ -45,6 +45,8 @@ export interface InitiativeCreateArgs {
   project?: string;
   summary?: string;
   status?: string;
+  /** The core idea as text, for an idea short enough to type. */
+  coreIdea?: string;
   /** A file holding the core idea, or `-` for stdin: a markdown body does not fit in argv. */
   coreIdeaFile?: string;
 }
@@ -438,6 +440,7 @@ const INITIATIVE_CREATE_OPTIONS: Record<string, keyof InitiativeCreateArgs> = {
   "--summary": "summary",
   "--status": "status",
   "--core-idea-file": "coreIdeaFile",
+  "--core-idea": "coreIdea",
 };
 const INITIATIVE_MEMORY_OPTIONS: Record<string, "kind" | "limit"> = { "--kind": "kind", "--limit": "limit" };
 
@@ -492,7 +495,7 @@ function parseInitiative(argv: string[]): Command {
     case "create": {
       const flags = parseFlags(rest, INITIATIVE_CREATE_OPTIONS, "initiative create");
       if (typeof flags === "string") return { kind: "usage-error", message: flags };
-      if (!flags.title) return { kind: "usage-error", message: "initiative create needs a title: opsee initiative create --title <title> [--project <key>] [--summary <text>] [--core-idea-file <path|->]" };
+      if (!flags.title) return { kind: "usage-error", message: "initiative create needs a title: opsee initiative create --title <title> [--project <key>] [--summary <text>] [--core-idea <text> | --core-idea-file <path|->]" };
       return { kind: "initiative-create", args: flags };
     }
     case "memory": {
@@ -606,7 +609,7 @@ export function usage(): string {
     "                                Run the Initiative's Ready Tasks one by one from this checkout:",
     "                                a Workspace and branch per Task, one unattended Worker turn each,",
     "                                Completion Reports into Initiative memory, moves on the board",
-    "  opsee foreman plan <initiativeId> [--account <name>] [--skill <to-issues|wayfinder|to-spec>]",
+    "  opsee foreman plan <initiativeId> [--account <name>] [--skill <initiative-decompose|initiative-map|initiative-spec>]",
     "      [--memory <n>]",
     "                                Open an attended planning session on the Initiative: a Workspace on",
     "                                a planning branch, the vendor's interactive session there with the",
@@ -660,9 +663,10 @@ export function usage(): string {
     "                                Title, status, summary and core idea. --context prints the whole",
     "                                work session instead: task tree, memory log and pull requests",
     "  opsee initiative create --title <title> [--project <key>] [--summary <text>]",
-    "      [--status <draft|active|paused|done|archived>] [--core-idea-file <path|->]",
-    "                                A new Initiative. The core idea is markdown read from a file, or",
-    "                                from stdin when the path is -",
+    "      [--status <draft|active|paused|done|archived>]",
+    "      [--core-idea <text> | --core-idea-file <path|->]",
+    "                                A new Initiative. The core idea is text given inline, or markdown",
+    "                                read from a file, or from stdin when the path is -",
     "  opsee initiative memory <initiativeId> [--kind <kind>] [--limit <n>]",
     "                                The append-only memory log, newest first",
     "  opsee initiative note <initiativeId> \"what happened\" [--kind <kind>]",

package/src/commands/foreman-plan.ts

@@ -76,7 +76,7 @@ export const SKILL_DIR_BY_VENDOR: Readonly<Record<Vendor, string>> = {
   codex: ".agents/skills",
 };
 
-/** `<dir>/.claude/skills/to-issues/SKILL.md`: the file that makes a skill available to a vendor. */
+/** `<dir>/.claude/skills/initiative-decompose/SKILL.md`: the file that makes a skill available to a vendor. */
 export function skillPath(dir: string, vendor: Vendor, skill: PlanningSkill): string {
   return join(dir, SKILL_DIR_BY_VENDOR[vendor], skill, "SKILL.md");
 }

package/src/commands/init.ts

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import type { Client } from "@connectrpc/connect";
 import type { ProjectService } from "@opsee/mcp-server/gen/api/v1/project_pb.js";
 import type { LabelService } from "@opsee/mcp-server/gen/api/v1/label_pb.js";
@@ -12,6 +12,7 @@ import { mergeClaudeMcpJson, mergeCodexConfigToml } from "../init/mcp-config.js"
 import { pickInstructionFile, pointerBlock, upsertPointerBlock } from "../init/pointer-block.js";
 import { CLAUDE_MCP_PATH, CODEX_CONFIG_PATH, SKILL_TARGETS, TRACKER_DOC_PATH } from "../init/paths.js";
 import { pickProject, type ProjectChoice } from "../init/project.js";
+import { planRetire, RETIRED_SKILLS } from "../init/retire.js";
 import { listSkillFiles, skillNames } from "../init/skills.js";
 import { findReadyLabel, READY_LABEL, renderTrackerDoc, type Named, type TrackerDocData } from "../init/tracker-doc.js";
 import { existingRecipe, inferRecipe, mergeRecipeJson, mergeRecipeYaml, NO_START_COMMAND, type RecipeDefaults, type RecipeFlags } from "../init/run-recipe-config.js";
@@ -62,7 +63,7 @@ export async function runInit(deps: InitDeps): Promise<number> {
   }
   const res = await deps.api.projects.getProjects({});
   const project = await pickProject(
-    res.projects.filter((p) => p.isActive).map((p) => ({ id: p.id, key: p.shortName, name: p.name })),
+    res.projects.filter((p) => p.isActive).map((p) => ({ id: p.id, key: p.shortName, name: p.name, slug: p.slug, companySlug: p.company?.slug })),
     deps.projectKey,
     deps.choose,
   );
@@ -81,6 +82,15 @@ export async function runInit(deps: InitDeps): Promise<number> {
       report.apply(rel, planWrite(read(deps.root, rel), file.content, file.style));
     }
   }
+  // The renamed skills' old folders, removed only where init wrote them and nobody edited them.
+  // Without this a repo set up before the rename keeps both, and /wayfinder goes on working
+  // beside /initiative-map with nothing to say which one is current.
+  for (const target of SKILL_TARGETS) {
+    for (const [retired, replacement] of Object.entries(RETIRED_SKILLS)) {
+      report.retire(join(target, retired), replacement);
+    }
+  }
+
   report.apply(TRACKER_DOC_PATH, planWrite(read(deps.root, TRACKER_DOC_PATH), doc, "markdown"));
   report.apply(CLAUDE_MCP_PATH, mergeClaudeMcpJson(read(deps.root, CLAUDE_MCP_PATH), deps.mcpUrl));
   report.apply(CODEX_CONFIG_PATH, mergeCodexConfigToml(read(deps.root, CODEX_CONFIG_PATH), deps.mcpUrl));
@@ -129,7 +139,7 @@ async function collect(api: InitApi, project: ProjectChoice): Promise<TrackerDoc
     .sort((a, b) => a.level - b.level);
   const labels = (await api.labels.getLabels({ projectId })).labels.filter((l) => l.isActive);
   return {
-    project: { id: projectId, name: project.name, key: project.key },
+    project: { id: projectId, name: project.name, key: project.key, slug: project.slug, companySlug: project.companySlug },
     labels: named(labels),
     board: { id: board.id, name: board.name },
     columns: named(columns),
@@ -150,6 +160,8 @@ const EXPLAIN: Partial<Record<WriteAction, string>> = {
 
 class Reporter {
   private counts = new Map<WriteAction, number>();
+  private removed = 0;
+  private keptRetired = 0;
 
   constructor(
     private root: string,
@@ -168,9 +180,30 @@ class Reporter {
     this.out(`${verb.padEnd(9)} ${rel}${why ? ` — ${why}` : ""}`);
   }
 
+  /** A folder from a skill this version no longer ships: every file of it that is still exactly
+   * what init wrote goes, and the folder with them once it is empty. Anything else is reported and
+   * left where it is. */
+  retire(rel: string, replacement: string) {
+    const dir = join(this.root, rel);
+    if (!existsSync(dir)) return;
+    const files = readdirSync(dir, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
+    for (const file of files) {
+      const path = join(file.parentPath ?? dir, file.name);
+      const plan = planRetire(readFileSync(path, "utf8"), replacement);
+      if (plan.action === "removed") rmSync(path);
+      this.removed += plan.action === "removed" ? 1 : 0;
+      this.keptRetired += plan.action === "kept" ? 1 : 0;
+      const shown = relative(this.root, path);
+      this.out(`${plan.action === "removed" ? "removed  " : "kept     "} ${shown}${plan.reason ? ` — ${plan.reason}` : ""}`);
+    }
+    // Only when nothing of the user's is left in it.
+    if (readdirSync(dir, { recursive: true, withFileTypes: true }).every((e) => !e.isFile())) rmSync(dir, { recursive: true });
+  }
+
   summary(): string {
     const n = (a: WriteAction) => this.counts.get(a) ?? 0;
-    const kept = n("kept-edited") + n("kept-unmanaged") + n("kept-invalid");
-    return `${n("create")} created, ${n("update")} updated, ${n("unchanged")} unchanged, ${kept} kept.`;
+    const kept = n("kept-edited") + n("kept-unmanaged") + n("kept-invalid") + this.keptRetired;
+    const removed = this.removed === 0 ? "" : `, ${this.removed} removed`;
+    return `${n("create")} created, ${n("update")} updated, ${n("unchanged")} unchanged, ${kept} kept${removed}.`;
   }
 }

package/src/commands/initiative.ts

@@ -77,7 +77,10 @@ function oneOf<T extends readonly string[]>(flag: string, value: string | undefi
  */
 async function resolveProject(deps: InitiativeDeps, key: string | undefined): Promise<ProjectChoice> {
   const res = await deps.clients.projects.getProjects({ pagination: { page: 1, pageSize: 200 } });
-  const projects: ProjectChoice[] = res.projects.map((p) => ({ id: p.id, key: p.key, name: p.name }));
+  // shortName, not `key`: api.v1.Project has no such field, so this read `undefined` for every
+  // project and printed "undefined (DevZero), undefined (Opsee), ..." before throwing on
+  // `undefined.toLowerCase()` the moment anyone passed --project. `opsee init` had it right.
+  const projects: ProjectChoice[] = res.projects.map((p) => ({ id: p.id, key: p.shortName, name: p.name }));
   const picked = await pickProject(projects, key, async () => null);
   if (typeof picked === "string") throw new InitiativeError(picked);
   return picked;
@@ -113,8 +116,20 @@ export async function runInitiativeShow(deps: InitiativeDeps, args: InitiativeSh
   return 0;
 }
 
-/** The core idea's body: a file, or stdin when the path is `-`. Absent when no flag was given. */
-async function coreIdeaOf(deps: InitiativeDeps, path: string | undefined): Promise<string | undefined> {
+/**
+ * The core idea's body: the text given inline, a file, or stdin when the path is `-`. Absent when
+ * neither flag was given.
+ *
+ * Inline text is here because the file was the only way in and a shell here-doc is a poor answer
+ * to "I already have the sentence". A body long enough to need markdown still wants a file; argv
+ * has a length limit and no way to hold a newline comfortably.
+ */
+async function coreIdeaOf(deps: InitiativeDeps, path: string | undefined, text: string | undefined): Promise<string | undefined> {
+  if (text !== undefined) {
+    if (path !== undefined) throw new InitiativeError("Pass --core-idea or --core-idea-file, not both");
+    if (text.trim() === "") throw new InitiativeError("The core idea given with --core-idea is empty");
+    return text;
+  }
   if (path === undefined) return undefined;
   if (path === "-") {
     const read = deps.readStdin ?? readStdin;
@@ -145,7 +160,7 @@ function readStdin(): Promise<string> {
 export async function runInitiativeCreate(deps: InitiativeDeps, args: InitiativeCreateArgs): Promise<number> {
   const status = oneOf("--status", args.status, INITIATIVE_STATUSES) ?? "draft";
   // Before the project is resolved: a bad flag should be refused without a round trip.
-  const coreIdea = await coreIdeaOf(deps, args.coreIdeaFile);
+  const coreIdea = await coreIdeaOf(deps, args.coreIdeaFile, args.coreIdea);
   const project = await resolveProject(deps, args.project);
   const res = await deps.clients.initiatives.addInitiative({
     projectId: project.id,

package/src/foreman/core/plan-context.ts

@@ -1,6 +1,6 @@
 /**
  * The planning session's context (story 10, `opsee foreman plan`): what an attended session is
- * handed as its first message so `/to-issues` (or `/wayfinder`, `/to-spec`) starts already knowing
+ * handed as its first message so `/initiative-decompose` (or `/initiative-map`, `/initiative-spec`) starts already knowing
  * last night's results. It is Context Assembly (core/context.ts) turned to the Initiative rather
  * than to one Task: the core idea, the whole task tree with statuses and blockers, the memory log
  * newest first with the Completion Reports (`outcome` entries) pulled out first, and the pull
@@ -14,10 +14,10 @@ import type { InitiativeContext, MemoryRecord, TrackerTask } from "../tracker-ad
 import { count, fenced, oneLine } from "./text.js";
 
 /** The Opsee-owned planning skills `opsee init` writes into the repo; the ones a session may be
- * opened on. `to-issues` is the default: it is what files Tasks into the Initiative. */
-export const PLANNING_SKILLS = ["to-issues", "wayfinder", "to-spec"] as const;
+ * opened on. `initiative-decompose` is the default: it is what files Tasks into the Initiative. */
+export const PLANNING_SKILLS = ["initiative-decompose", "initiative-map", "initiative-spec"] as const;
 export type PlanningSkill = (typeof PLANNING_SKILLS)[number];
-export const DEFAULT_PLANNING_SKILL: PlanningSkill = "to-issues";
+export const DEFAULT_PLANNING_SKILL: PlanningSkill = "initiative-decompose";
 
 export function isPlanningSkill(name: string): name is PlanningSkill {
   return (PLANNING_SKILLS as readonly string[]).includes(name);

package/src/init/pointer-block.ts

@@ -14,7 +14,7 @@ export function pointerBlock(trackerDocPath: string): string {
     POINTER_BEGIN,
     "## Agent skills",
     "",
-    "`opsee init` installs Opsee's planning skills (`/wayfinder`, `/to-spec`, `/to-issues`) into",
+    "`opsee init` installs Opsee's planning skills (`/initiative-map`, `/initiative-spec`, `/initiative-decompose`) into",
     "`.claude/skills/` and `.agents/skills/`, and writes the tracker doc they read to",
     `\`${trackerDocPath}\`. Opsee owns those files; edit them upstream and re-run \`opsee init\`,`,
     "which updates what it wrote and leaves any file you changed alone.",

package/src/init/project.ts

@@ -2,6 +2,11 @@ export interface ProjectChoice {
   id: number;
   key: string;
   name: string;
+  /** The project's and its company's URL slugs, when the response carried them: the tracker doc
+   * prints an Initiative's page from the pair, and a doc that can link is what sends a person
+   * back to Opsee at the end of a planning session. Absent leaves the doc saying so. */
+  slug?: string;
+  companySlug?: string;
 }
 
 /** Which project the repo is set up for: `--project <key>` when given, the only one when there

package/src/init/retire.ts

@@ -0,0 +1,41 @@
+import { hashOf, parseMarker } from "./managed.js";
+
+/**
+ * Skill folders `opsee init` used to write and no longer does.
+ *
+ * The names changed to Opsee's vocabulary (`/initiative-map`, `/initiative-spec`,
+ * `/initiative-decompose`). A repo set up before that has both sets on disk, and the old ones
+ * still work — which is the confusing part, not a broken one: two commands that do the same thing
+ * and no signal which is current. So init removes what it wrote, and only that.
+ */
+export const RETIRED_SKILLS: Readonly<Record<string, string>> = {
+  wayfinder: "initiative-map",
+  "to-spec": "initiative-spec",
+  "to-issues": "initiative-decompose",
+};
+
+export type RetireAction =
+  /** Written by opsee init and untouched since: safe to delete, because opsee init can write it again. */
+  | "removed"
+  /** Carries our marker but has been edited, or carries none at all: the user's file now. */
+  | "kept";
+
+export interface RetirePlan {
+  action: RetireAction;
+  /** Why it was kept, for the line the reporter prints. */
+  reason?: string;
+}
+
+/**
+ * Whether a file left behind by a retired skill is ours to delete.
+ *
+ * Deleting only unmodified files is the whole point: someone who edited a fork of `/wayfinder`
+ * meant it, and losing that to a rename would be an unrecoverable surprise. The kept file is
+ * reported rather than removed, with the new name to move to.
+ */
+export function planRetire(existing: string, replacement: string): RetirePlan {
+  const marked = parseMarker(existing);
+  if (!marked) return { action: "kept", reason: `not written by opsee init; delete it yourself once /${replacement} suits you` };
+  if (hashOf(marked.body) !== marked.hash) return { action: "kept", reason: `edited since opsee init wrote it; /${replacement} replaces it` };
+  return { action: "removed" };
+}

package/src/init/skills.ts

@@ -3,7 +3,7 @@ import { join, relative } from "node:path";
 import type { MarkerStyle } from "./managed.js";
 
 export interface SkillFile {
-  /** Path relative to the skills dir, e.g. `to-issues/SKILL.md`. */
+  /** Path relative to the skills dir, e.g. `initiative-decompose/SKILL.md`. */
   rel: string;
   content: string;
   style: MarkerStyle;

package/src/init/tracker-doc.ts

@@ -9,7 +9,7 @@ export interface Named {
 }
 
 export interface TrackerDocData {
-  project: { id: number; name: string; key: string };
+  project: { id: number; name: string; key: string; slug?: string; companySlug?: string };
   labels: Named[];
   board: Named;
   /** In board order. */
@@ -69,6 +69,17 @@ export function findReadyLabel(labels: Named[]): Named | undefined {
 
 const idList = (items: Named[]) => items.map((i) => `${i.name} \`${i.id}\``).join(", ");
 
+/** Where an Initiative lives in the app, for the doc to hand back to a human at the end of a
+ * planning session. Both slugs or nothing: half a URL is worse than a sentence saying where to
+ * look, and a link with an empty segment reads as a bug in Opsee rather than a missing slug.
+ * Returns the phrase already formatted, backticks included, so the fallback is not a sentence
+ * rendered as code. */
+function initiativeUrl(project: TrackerDocData["project"]): string {
+  const app = (process.env.OPSEE_APP_URL || "https://opsee.ai").replace(/\/+$/, "");
+  if (!project.slug || !project.companySlug) return "the Initiatives page in Opsee";
+  return `\`${app}/${project.companySlug}/${project.slug}/initiatives/<uuid>\``;
+}
+
 export function renderTrackerDoc(template: string, data: TrackerDocData): string {
   const ready = findReadyLabel(data.labels);
   const bug = data.types.find((t) => /bug/.test(norm(t.name))) ?? data.types[0];
@@ -94,6 +105,7 @@ export function renderTrackerDoc(template: string, data: TrackerDocData): string
     BUG_TYPE_ID: String(bug.id),
     TYPES_LINE: idList(data.types),
     PRIORITIES_LINE: idList(data.priorities),
+    INITIATIVE_URL: initiativeUrl(data.project),
   };
   const rendered = template.replace(/\{\{([A-Z_]+)\}\}/g, (whole, key: string) => {
     const value = values[key];

package/templates/issue-tracker.md

@@ -95,15 +95,15 @@ Avoid file paths and code in the description except for a prototype-derived snip
 
 ## Skill hooks
 
-### `/to-spec` and `/to-prd`: "publish to the issue tracker"
+### `/initiative-spec` (and an upstream `/to-prd`): "publish to the issue tracker"
 
 A spec or PRD becomes an **Initiative**, not a Task.
 
 1. `opsee_create_initiative` with `projectId: {{PROJECT_ID}}`, the spec title, a one- or two-line `summary`, `status: "draft"`, and the full spec body (the skill's template) as `coreIdea` in markdown.
-2. Do **not** try to apply `ready-for-agent` to the Initiative; labels are Task-level. The spec's readiness is recorded by `/to-issues` when it files the Tasks and labels them. If the spec was written from a repo file, note the file path in the summary so the two stay linked.
-3. Report the Initiative by title and id.
+2. Do **not** try to apply `ready-for-agent` to the Initiative; labels are Task-level. The spec's readiness is recorded by `/initiative-decompose` when it files the Tasks and labels them. If the spec was written from a repo file, note the file path in the summary so the two stay linked.
+3. Report the Initiative by title, id **and link** — {{INITIATIVE_URL}} — and say what it is now waiting for: a breakdown, which is `/initiative-decompose` against this same Initiative. A spec nobody can open is a spec nobody reads.
 
-### `/to-issues`: "publish the issues"
+### `/initiative-decompose`: "publish the issues"
 
 Slices become **Tasks inside the Initiative** that holds the spec. Find or create that Initiative first.
 
@@ -112,6 +112,9 @@ Slices become **Tasks inside the Initiative** that holds the spec. Find or creat
 3. If the Initiative **already has Tasks** (re-planning, or a wayfinder map that has become executable), use `opsee_reconcile_initiative`: tag kept Tasks with `existingTaskId`, add new ones without, run with `dryRun: true`, show the human the changeset, and only then run with `dryRun: false`. Tasks that carry execution state are never deleted by reconcile; the human decides their fate.
 4. Label the **AFK** slices `ready-for-agent` with `opsee_bulk_update_tasks` (`labelIds: [{{READY_LABEL_ID}}]`, plus an area label if useful). **HITL** slices get no `ready-for-agent`; put the reason a human is needed in the Goal and leave them for an attended turn.
 5. Never edit or close the Initiative or any parent Task.
+6. **Report where the work went and what can start.** Give the Initiative's link — {{INITIATIVE_URL}} — the count of Tasks filed, and how many carry `ready-for-agent`. Then name the two ways forward, because the label means nothing to a human who does not know what reads it:
+   - **Unattended:** `opsee foreman run <initiativeId>` takes the `ready-for-agent` Tasks one at a time, each in its own workspace and branch, and opens a draft MR per Task. It needs the Foreman set up on their machine (`opsee foreman account add`, see the CLI's README).
+   - **By hand, here:** the Tasks are ordinary issues. They can be worked in this session or any other, and the Initiative's memory is where the record goes either way.
 
 The dependency-ordered publish the skill describes ("blockers first so you can reference real ids") is unnecessary here: decompose and reconcile take the whole graph with `ref`s and create it atomically.
 
@@ -148,10 +151,10 @@ Commit messages and MR titles carry `OPS-nnn`. Resolve it with `opsee_list_tasks
 
 ## Wayfinding operations
 
-Used by `/wayfinder`. The whole effort, from charting to execution, lives in **one Initiative**, so the decisions the map records are already in the memory log the Foreman's Context Assembly reads when `/to-issues` later files execution Tasks into it.
+Used by `/initiative-map`. The whole effort, from charting to execution, lives in **one Initiative**, so the decisions the map records are already in the memory log the Foreman's Context Assembly reads when `/initiative-decompose` later files execution Tasks into it.
 
 - **Map**: a Task labelled `wayfinder:map` inside the Initiative, type Task, in **To Do**, whose description is the map body (Destination, Notes, Decisions so far, Not yet specified, Out of scope). The Initiative's `coreIdea` carries the Destination and Notes as well, so `opsee_get_initiative_context` orients a session without opening the map. Create the Initiative first (`status: "draft"`), then the map Task, then `opsee_link_task_to_initiative`.
-- **Labels**: `wayfinder:map` and `wayfinder:<type>` for `research`, `prototype`, `grilling`, `task` do not exist in the project until first use. Check `opsee_list_labels`; create missing ones with `opsee_create_label` (`projectId: {{PROJECT_ID}}`) and record the ids in the map's Notes so later sessions skip the lookup.
+- **Labels**: `wayfinder:map` and `wayfinder:<type>` (the prefix is the label's, not the skill's: the skill is `/initiative-map`, and renaming the labels would orphan every map already charted) for `research`, `prototype`, `grilling`, `task` do not exist in the project until first use. Check `opsee_list_labels`; create missing ones with `opsee_create_label` (`projectId: {{PROJECT_ID}}`) and record the ids in the map's Notes so later sessions skip the lookup.
 - **Child ticket**: a Task with `parentTaskId` = the map's id, linked to the same Initiative, labelled `wayfinder:<type>`, description `## Question` only. Never label a wayfinder ticket `ready-for-agent`: decision tickets are for planning sessions, not the Foreman. Create tickets first, then wire blocking in a second pass once ids exist.
 - **Blocking**: native `BLOCKS` TaskDependency edges (`opsee_create_task_dependency`, blocker → blocked). Opsee renders them on the Task and in the Initiative graph, so the frontier is visible without opening the map. A ticket is unblocked when every Task blocking it is in **Done**.
 - **Frontier query**: `opsee_list_tasks` with `projectId: {{PROJECT_ID}}`, `parentTaskId: <map id>`, `unassigned: true`, `sortBy: "display_order"`, then drop any Task in Done/Archived and any whose `opsee_list_task_dependencies` shows an incoming `BLOCKED_BY` from a Task not yet Done. The slices in `opsee_get_initiative_context` give the same answer for the whole Initiative at once. First in map order wins.
@@ -159,4 +162,4 @@ Used by `/wayfinder`. The whole effort, from charting to execution, lives in **o
 - **Resolve**: post the answer with `opsee_add_comment` on the ticket; record it in the Initiative with `opsee_add_initiative_memory` (`kind: "decision"`, `sourceType: "task"`, `sourceId: <ticket id>`); move the ticket to **Done**; then `opsee_update_task` on the map to append one line to *Decisions so far*: `- <ticket title> (OPS-nnn) — <one-line gist>`. Re-read the map's description immediately before editing it, because other sessions may be working the map concurrently.
 - **Out of scope**: move the ticket to **Done**, add a line to the map's *Out of scope* section linking it, and leave *Decisions so far* untouched.
 - **Research tickets**: findings are captured on a throwaway `research/<name>` branch; link the branch or file path from the ticket's resolution comment rather than pasting the findings.
-- **Graduate to execution**: when the map has no open tickets, run `/to-issues` against the same Initiative. Use `opsee_reconcile_initiative` (the Initiative already has Tasks) and keep the closed wayfinder tickets with `existingTaskId` so the record of the route survives.
+- **Graduate to execution**: when the map has no open tickets, run `/initiative-decompose` against the same Initiative. Use `opsee_reconcile_initiative` (the Initiative already has Tasks) and keep the closed wayfinder tickets with `existingTaskId` so the record of the route survives.

package/skills/to-issues/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "To Issues (Opsee)"
-  short_description: "Split a plan into tracer-bullet Tasks in an Opsee Initiative"
-policy:
-  allow_implicit_invocation: false

package/skills/to-spec/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "To Spec (Opsee)"
-  short_description: "Turn a conversation into a spec published as a draft Opsee Initiative"
-policy:
-  allow_implicit_invocation: false

package/skills/wayfinder/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Wayfinder (Opsee)"
-  short_description: "Map a large effort as decision tickets in an Opsee Initiative"
-policy:
-  allow_implicit_invocation: false