@weave-tools/weave-it 0.1.0

package/dist/cli.js

@@ -0,0 +1,4538 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/add.ts
+import { Command } from "commander";
+
+// src/lib/add-folder.ts
+import path6 from "path";
+import { realpath as realpath4, stat as stat2 } from "fs/promises";
+
+// src/lib/folders.ts
+import path from "path";
+import { realpath } from "fs/promises";
+
+// src/lib/files.ts
+import { constants } from "fs";
+import { access, mkdir, readFile, readdir, rename, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function pathExists(path14) {
+  try {
+    await access(path14, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeNewFile(path14, contents) {
+  await writeFile(path14, contents, { flag: "wx" });
+}
+async function writeFileIfMissing(path14, contents) {
+  if (await pathExists(path14)) {
+    return false;
+  }
+  await writeNewFile(path14, contents);
+  return true;
+}
+async function writeFileAtomic(path14, contents) {
+  const tempPath = `${path14}.${process.pid}.tmp`;
+  await writeFile(tempPath, contents);
+  await rename(tempPath, path14);
+}
+async function ensureDir(path14) {
+  await mkdir(path14, { recursive: true });
+}
+async function createDirExclusive(path14) {
+  await mkdir(path14, { recursive: false });
+}
+async function ensureDirectory(path14) {
+  const value = await stat(path14);
+  if (!value.isDirectory()) {
+    throw new Error(`Expected a directory: ${path14}`);
+  }
+}
+async function isDirectoryEmpty(path14) {
+  const entries = await readdir(path14);
+  return entries.length === 0;
+}
+async function movePath(source, target) {
+  await rename(source, target);
+}
+async function readJsonCache(path14) {
+  try {
+    const contents = await readFile(path14, "utf8");
+    return JSON.parse(contents);
+  } catch {
+    return null;
+  }
+}
+async function writeJsonCache(path14, data) {
+  try {
+    await mkdir(dirname(path14), { recursive: true });
+    await writeFileAtomic(path14, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function git(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd, env: gitEnv() });
+    const value = stdout.trim();
+    return value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function gitEnv() {
+  return {
+    ...process.env,
+    GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME ?? "Weave",
+    GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL ?? "weave@example.invalid",
+    GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME ?? "Weave",
+    GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL ?? "weave@example.invalid"
+  };
+}
+async function findGitRoot(cwd) {
+  return git(["rev-parse", "--show-toplevel"], cwd);
+}
+async function currentBranch(cwd) {
+  const gitRoot = await findGitRoot(cwd);
+  if (!gitRoot) {
+    return void 0;
+  }
+  return git(["branch", "--show-current"], gitRoot);
+}
+async function isWorktreeDirty(cwd) {
+  const gitRoot = await findGitRoot(cwd);
+  if (!gitRoot) {
+    return false;
+  }
+  return Boolean(await git(["status", "--porcelain"], gitRoot));
+}
+async function branchExists(cwd, branch) {
+  const gitRoot = await findGitRoot(cwd);
+  if (!gitRoot) {
+    return false;
+  }
+  return Boolean(await git(["rev-parse", "--verify", `refs/heads/${branch}`], gitRoot));
+}
+async function checkoutBranch(cwd, branch) {
+  const gitRoot = await findGitRoot(cwd);
+  await runGitRequired(["checkout", branch], gitRoot ?? cwd);
+}
+async function createBranch(cwd, branch) {
+  const gitRoot = await findGitRoot(cwd);
+  await runGitRequired(["checkout", "-b", branch], gitRoot ?? cwd);
+}
+async function currentHead(cwd) {
+  const gitRoot = await findGitRoot(cwd);
+  if (!gitRoot) {
+    return void 0;
+  }
+  return git(["rev-parse", "HEAD"], gitRoot);
+}
+async function getGitRemote(cwd) {
+  return git(["config", "--get", "remote.origin.url"], cwd);
+}
+async function runGitRequired(args, cwd) {
+  await execFileAsync("git", args, { cwd, env: gitEnv() });
+}
+async function cloneRepo(url, destinationDir, cwd) {
+  await runGitRequired(["clone", "--", url, destinationDir], cwd);
+}
+
+// src/lib/ids.ts
+function slugify(value, fallback) {
+  const slug = value.trim().toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : fallback;
+}
+function titleFromSlug(value) {
+  return value.replace(/[-_]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+
+// src/lib/folders.ts
+async function resolveFolder(input) {
+  const candidate = input.targetPath ? path.resolve(input.cwd, input.targetPath) : input.cwd;
+  await ensureDirectory(candidate);
+  const gitRoot = await findGitRoot(candidate);
+  const folderPath = await realpath(gitRoot ?? candidate);
+  const basename2 = path.basename(folderPath);
+  const id = input.id ?? slugify(basename2, "folder");
+  const gitRemote = gitRoot ? await getGitRemote(folderPath) : void 0;
+  return {
+    id,
+    path: folderPath,
+    name: titleFromSlug(id) || basename2,
+    kind: input.kind ?? "app",
+    gitRemote
+  };
+}
+
+// src/lib/session-state.ts
+import os from "os";
+import path2 from "path";
+import { readFile as readFile2 } from "fs/promises";
+import YAML from "yaml";
+function defaultSessionPath() {
+  if (process.env.WEAVE_SESSION_PATH) {
+    return path2.resolve(process.env.WEAVE_SESSION_PATH);
+  }
+  return path2.join(os.homedir(), ".cache", "weave", "current-session.yml");
+}
+async function loadCurrentSession(sessionPath = defaultSessionPath()) {
+  if (!await pathExists(sessionPath)) {
+    return void 0;
+  }
+  return YAML.parse(await readFile2(sessionPath, "utf8"));
+}
+async function saveCurrentSession(session, sessionPath = defaultSessionPath()) {
+  await ensureDir(path2.dirname(sessionPath));
+  await writeFileAtomic(sessionPath, YAML.stringify(session));
+}
+function createCurrentSession(folder, now) {
+  const session = {
+    version: 1,
+    updated_at: now.toISOString(),
+    folders: {}
+  };
+  addFolderToSession(session, folder, now);
+  return session;
+}
+function addFolderToSession(session, folder, now) {
+  const existingId = findFolderByPath(session, folder.path);
+  if (existingId) {
+    session.updated_at = now.toISOString();
+    return { added: false, id: existingId, session };
+  }
+  const id = uniqueFolderId(session, folder.id);
+  const sessionFolder = {
+    path: folder.path,
+    name: folder.name,
+    kind: folder.kind
+  };
+  if (folder.gitRemote) {
+    sessionFolder.git_remote = folder.gitRemote;
+  }
+  session.folders[id] = sessionFolder;
+  session.updated_at = now.toISOString();
+  return { added: true, id, session };
+}
+function findFolderByPath(session, folderPath) {
+  return Object.entries(session.folders).find(([, folder]) => folder.path === folderPath)?.[0];
+}
+function ensureFolderInSession(session, folderPath, now) {
+  const existingId = findFolderByPath(session, folderPath);
+  if (existingId) {
+    session.updated_at = now.toISOString();
+    return existingId;
+  }
+  const basename2 = path2.basename(folderPath);
+  const id = uniqueFolderId(session, slugify(basename2, "folder"));
+  session.folders[id] = {
+    path: folderPath,
+    name: titleFromSlug(id) || basename2,
+    kind: "app"
+  };
+  session.updated_at = now.toISOString();
+  return id;
+}
+function setCurrentChangeForPath(session, folderPath, change, now) {
+  const id = ensureFolderInSession(session, folderPath, now);
+  session.folders[id].current_change = {
+    ...change,
+    updated_at: now.toISOString()
+  };
+  session.updated_at = now.toISOString();
+  return id;
+}
+function setCurrentArtifactForPath(session, folderPath, artifact, now) {
+  const id = ensureFolderInSession(session, folderPath, now);
+  session.folders[id].current_artifact = {
+    ...artifact,
+    updated_at: now.toISOString()
+  };
+  session.updated_at = now.toISOString();
+  return id;
+}
+function clearCurrentArtifactForPath(session, folderPath, now) {
+  const id = ensureFolderInSession(session, folderPath, now);
+  delete session.folders[id].current_artifact;
+  session.updated_at = now.toISOString();
+  return id;
+}
+function currentArtifactForPath(session, folderPath) {
+  const id = session ? findFolderByPath(session, folderPath) : void 0;
+  return id ? session?.folders[id]?.current_artifact : void 0;
+}
+function uniqueFolderId(session, id) {
+  if (!session.folders[id]) {
+    return id;
+  }
+  let index = 2;
+  while (session.folders[`${id}-${index}`]) {
+    index += 1;
+  }
+  return `${id}-${index}`;
+}
+
+// src/lib/weave-scaffold.ts
+import path3 from "path";
+import YAML2 from "yaml";
+
+// src/lib/sync.ts
+import { createHash } from "crypto";
+function hashDocument(contents) {
+  return `sha256:${createHash("sha256").update(contents).digest("hex")}`;
+}
+
+// src/lib/weave-scaffold.ts
+async function ensureWeaveScaffold(input) {
+  const wikiDir = path3.join(input.folder.path, "wiki");
+  const metadataDir = path3.join(input.folder.path, ".weave");
+  const created = [];
+  const knowledgeIndex = knowledgeIndexTemplate();
+  const knowledgeReadme = knowledgeReadmeTemplate();
+  const domainsReadme = domainsReadmeTemplate();
+  const sharedReadme = sharedReadmeTemplate();
+  const knowledgeDir = path3.join(wikiDir, "knowledge");
+  const changesDir = path3.join(wikiDir, "changes");
+  const changesExisted = await pathExists(changesDir);
+  await ensureDir(knowledgeDir);
+  await ensureDir(path3.join(knowledgeDir, "domains"));
+  await ensureDir(path3.join(knowledgeDir, "shared"));
+  await ensureDir(changesDir);
+  await ensureDir(metadataDir);
+  if (await writeFileIfMissing(path3.join(metadataDir, "sync.yml"), syncTemplate(knowledgeIndex))) {
+    created.push(".weave/sync.yml");
+  }
+  if (await writeFileIfMissing(path3.join(knowledgeDir, "index.md"), knowledgeIndex)) {
+    created.push("wiki/knowledge/index.md");
+  }
+  if (await writeFileIfMissing(path3.join(knowledgeDir, "README.md"), knowledgeReadme)) {
+    created.push("wiki/knowledge/README.md");
+  }
+  if (await writeFileIfMissing(path3.join(knowledgeDir, "domains", "README.md"), domainsReadme)) {
+    created.push("wiki/knowledge/domains/README.md");
+  }
+  if (await writeFileIfMissing(path3.join(knowledgeDir, "shared", "README.md"), sharedReadme)) {
+    created.push("wiki/knowledge/shared/README.md");
+  }
+  if (!changesExisted) {
+    created.push("wiki/changes/");
+  }
+  return { wikiDir, metadataDir, created };
+}
+function syncTemplate(knowledgeIndex) {
+  return YAML2.stringify({
+    version: 1,
+    documents: {
+      "knowledge.index": {
+        path: "wiki/knowledge/index.md",
+        hash: hashDocument(knowledgeIndex),
+        status: "synced"
+      }
+    }
+  });
+}
+function knowledgeIndexTemplate() {
+  return `# Product Knowledge
+
+This folder contains current product knowledge for this repo/folder.
+
+## Domains
+
+_Add product domains here as they become relevant._
+
+Examples:
+- Billing
+- Permissions
+- Onboarding
+- Notifications
+`;
+}
+function knowledgeReadmeTemplate() {
+  return `# Knowledge Structure
+
+This folder contains current-state behavioral specs. Historical change provenance belongs in \`wiki/changes/**\`.
+
+Use this progressive structure:
+
+\`\`\`text
+wiki/knowledge/
+  index.md
+  README.md
+  domains/
+    README.md
+    <domain>/
+      index.md
+      overview.md
+      glossary.md
+      source-map.md
+      features/
+        <feature>/
+          behavior.md
+          decision-tables.md
+          lifecycle.md
+          permissions.md
+          source-map.md
+      domain-wide/
+        lifecycle.md
+        permissions.md
+        visibility.md
+        notifications.md
+        approvals.md
+        edge-cases.md
+  shared/
+    README.md
+    <shared-behavior>/
+      behavior.md
+      source-map.md
+\`\`\`
+
+- \`domains/\` contains product or system areas users naturally name.
+- \`features/\` contains independently understandable behavior inside a domain.
+- \`domain-wide/\` contains behavior that coordinates multiple features inside one domain.
+- \`shared/\` contains behavior reused across multiple domains.
+
+## Guided Templates
+
+\`behavior.md\` is the core current-state spec:
+
+\`\`\`md
+# <Feature Or Shared Behavior>
+
+## Purpose
+## Current Behavior
+## Domain Model
+## Configuration Dimensions
+## Behavioral Rules
+## Decision Tables
+## Lifecycle
+## Permissions And Visibility
+## Integrations And Side Effects
+## Edge Cases
+## Invariants
+## Source Anchors
+## Change History
+## Open Questions
+\`\`\`
+
+\`Purpose\`, \`Current Behavior\`, \`Source Anchors\`, and \`Change History\` are strongly recommended. Other sections may be omitted when they do not apply.
+
+\`decision-tables.md\` is optional and focused on permutations:
+
+\`\`\`md
+# <Feature> Decision Tables
+
+## Table: <Scenario>
+
+| Dimension | Value | Outcome |
+| --- | --- | --- |
+
+## Notes
+## Source Anchors
+\`\`\`
+
+\`source-map.md\` connects behavior to reality:
+
+\`\`\`md
+# <Domain Or Feature> Source Map
+
+## Core Product Surfaces
+## Source Anchors
+## Tests
+## Config And Flags
+## Jobs And Side Effects
+## External Integrations
+## Ownership Notes
+\`\`\`
+
+\`knowledge-delta.md\` lives under \`wiki/changes/<change-id>/\` and bridges one change to current knowledge:
+
+\`\`\`md
+# Knowledge Delta
+
+## Durable Behavior Changes
+## Affected Knowledge Areas
+## Knowledge Files Updated
+## No-Impact Rationale
+## Source Evidence
+## Follow-Up Knowledge Work
+\`\`\`
+`;
+}
+function domainsReadmeTemplate() {
+  return `# Domains
+
+Create one folder per product or system domain. A domain folder may start small and grow as behavior becomes heavier.
+
+Recommended domain files:
+
+- \`index.md\`: entry point and links to important specs
+- \`overview.md\`: domain summary
+- \`glossary.md\`: domain terms
+- \`source-map.md\`: code, tests, flags, jobs, integrations, and ownership
+- \`features/<feature>/behavior.md\`: feature-level current behavior
+- \`domain-wide/*.md\`: behavior that coordinates multiple features in the domain
+`;
+}
+function sharedReadmeTemplate() {
+  return `# Shared Behavior
+
+Use this folder for behavior reused across multiple domains, such as permissions, approvals, notifications, audit logs, privacy, retention, imports, exports, and integrations.
+
+Prefer keeping behavior inside one domain until multiple domains depend on it. When behavior becomes shared, document the shared model here and the domain-specific integration inside the domain.
+`;
+}
+
+// src/lib/workspace-mode.ts
+import { readFile as readFile3 } from "fs/promises";
+import path4 from "path";
+import { realpath as realpath2 } from "fs/promises";
+import YAML3 from "yaml";
+async function findWorkspaceMode(startPath) {
+  let current = await realpath2(startPath);
+  for (; ; ) {
+    const workspaceYmlPath = path4.join(current, ".weave", "workspace.yml");
+    if (await pathExists(workspaceYmlPath)) {
+      const parsed = await readWorkspaceYml(workspaceYmlPath);
+      if (!parsed) {
+        return void 0;
+      }
+      const mode = parsed.mode === "workspace" ? "workspace" : "repo";
+      return {
+        mode,
+        workspacePath: current,
+        workspaceYmlPath
+      };
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function resolveChangeContext(startPath, sessionPath = defaultSessionPath()) {
+  const workspace = await findWorkspaceMode(startPath);
+  if (!workspace) {
+    return void 0;
+  }
+  const session = await loadCurrentSession(sessionPath);
+  const folderId = session ? findFolderByPath(session, workspace.workspacePath) : void 0;
+  const folder = folderId ? session?.folders[folderId] : void 0;
+  return {
+    mode: workspace.mode,
+    rootPath: workspace.workspacePath,
+    workspaceYmlPath: workspace.workspaceYmlPath,
+    folderId,
+    folderName: folder?.name
+  };
+}
+async function readWorkspaceYml(workspaceYmlPath) {
+  try {
+    const parsed = YAML3.parse(await readFile3(workspaceYmlPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function isWorkspaceMode(result3) {
+  return result3?.mode === "workspace";
+}
+
+// src/lib/workspace-repos.ts
+import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+import { realpath as realpath3 } from "fs/promises";
+import YAML4 from "yaml";
+var GIT_URL_PATTERN = /^(git@|https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/)/i;
+function isGitUrl(input) {
+  return GIT_URL_PATTERN.test(input.trim());
+}
+function repoNameFromUrl(url) {
+  const trimmed = url.trim().replace(/\/$/, "");
+  const lastSegment = trimmed.split("/").pop() ?? trimmed;
+  const withoutGit = lastSegment.replace(/\.git$/i, "");
+  return withoutGit || "repo";
+}
+async function isInsideWorkspace(workspacePath, candidatePath) {
+  const resolvedWorkspace = await realpath3(workspacePath);
+  const resolvedCandidate = await realpath3(candidatePath);
+  const relative2 = path5.relative(resolvedWorkspace, resolvedCandidate);
+  if (relative2 === "") {
+    return true;
+  }
+  if (path5.isAbsolute(relative2)) {
+    return false;
+  }
+  return !relative2.startsWith(`..${path5.sep}`) && relative2 !== "..";
+}
+function relativeRepoPath(workspacePath, repoAbsolutePath) {
+  const relative2 = path5.relative(workspacePath, repoAbsolutePath);
+  return relative2.split(path5.sep).join("/");
+}
+function gitignoreEntryForRelativePath(relativePath) {
+  const normalized = relativePath.split(path5.sep).join("/").replace(/^\/+/, "").replace(/\/+$/, "");
+  return `/${normalized}/`;
+}
+async function readWorkspaceMetadata(workspacePath) {
+  const workspaceYmlPath = path5.join(workspacePath, ".weave", "workspace.yml");
+  if (!await pathExists(workspaceYmlPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = YAML4.parse(await readFile4(workspaceYmlPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    const repos = parseRepos(parsed.repos);
+    return {
+      version: typeof parsed.version === "number" ? parsed.version : void 0,
+      mode: typeof parsed.mode === "string" ? parsed.mode : void 0,
+      name: typeof parsed.name === "string" ? parsed.name : void 0,
+      repos
+    };
+  } catch {
+    return void 0;
+  }
+}
+function parseRepos(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  const repos = {};
+  for (const [id, entry] of Object.entries(value)) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const record = entry;
+    const repoPath = typeof record.path === "string" ? record.path : void 0;
+    const kind = typeof record.kind === "string" ? record.kind : void 0;
+    if (!repoPath || !kind) {
+      continue;
+    }
+    repos[id] = {
+      path: repoPath,
+      kind,
+      ...typeof record.remote === "string" ? { remote: record.remote } : {}
+    };
+  }
+  return repos;
+}
+function findRegisteredRepoByPath(metadata, relativePath) {
+  const normalized = normalizeRepoPath(relativePath);
+  return Object.entries(metadata.repos).find(([, entry]) => normalizeRepoPath(entry.path) === normalized)?.[0];
+}
+function normalizeRepoPath(repoPath) {
+  return repoPath.split(path5.sep).join("/").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+async function appendGitignoreEntry(workspacePath, relativePath) {
+  const gitignorePath = path5.join(workspacePath, ".gitignore");
+  const entry = gitignoreEntryForRelativePath(relativePath);
+  const existing = await pathExists(gitignorePath) ? await readFile4(gitignorePath, "utf8") : "";
+  const lines = existing.split("\n");
+  if (lines.some((line) => line.trim() === entry.trim())) {
+    return;
+  }
+  const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  const prefix = existing.length > 0 ? separator : "";
+  await writeFile2(gitignorePath, `${existing}${prefix}${entry}
+`);
+}
+async function registerRepoInWorkspaceMetadata(workspacePath, input) {
+  const workspaceYmlPath = path5.join(workspacePath, ".weave", "workspace.yml");
+  const metadata = await readWorkspaceMetadata(workspacePath) ?? {
+    version: 1,
+    mode: "workspace",
+    name: path5.basename(workspacePath),
+    repos: {}
+  };
+  const normalizedPath = normalizeRepoPath(input.relativePath);
+  const existing = metadata.repos[input.id];
+  if (existing && normalizeRepoPath(existing.path) !== normalizedPath) {
+    throw new Error(
+      `Workspace repo id "${input.id}" is already registered for a different path (${existing.path}). Pass --id with a different value.`
+    );
+  }
+  const collision = Object.entries(metadata.repos).find(
+    ([id, entry]) => id !== input.id && normalizeRepoPath(entry.path) === normalizedPath
+  );
+  if (collision) {
+    throw new Error(`Path is already registered in workspace as "${collision[0]}".`);
+  }
+  metadata.repos[input.id] = {
+    path: normalizedPath,
+    kind: input.kind,
+    ...input.remote ? { remote: input.remote } : {}
+  };
+  await writeFile2(
+    workspaceYmlPath,
+    YAML4.stringify({
+      version: metadata.version ?? 1,
+      mode: metadata.mode ?? "workspace",
+      name: metadata.name ?? path5.basename(workspacePath),
+      repos: metadata.repos
+    })
+  );
+}
+async function registerRepoIntoWorkspace(input) {
+  await appendGitignoreEntry(input.workspacePath, input.relativePath);
+  await registerRepoInWorkspaceMetadata(input.workspacePath, {
+    id: input.id,
+    relativePath: input.relativePath,
+    kind: input.kind,
+    remote: input.remote
+  });
+  return {
+    id: input.id,
+    relativePath: input.relativePath
+  };
+}
+function defaultRepoId(relativePath, explicitId) {
+  if (explicitId) {
+    return explicitId;
+  }
+  const basename2 = path5.basename(relativePath.split("/").join(path5.sep));
+  return slugify(basename2, "repo");
+}
+function workspaceGitignoreBaseTemplate() {
+  return [".DS_Store", "node_modules/"].join("\n") + "\n";
+}
+function listReposForDisplay(metadata) {
+  return Object.entries(metadata.repos).map(([id, entry]) => ({
+    id,
+    path: entry.path,
+    kind: entry.kind,
+    ...entry.remote ? { remote: entry.remote } : {}
+  }));
+}
+
+// src/lib/add-folder.ts
+async function addFolder(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadCurrentSession(sessionPath);
+  if (!session) {
+    return {
+      status: "no_session",
+      message: "No current Weave session found. Run `weave init` first."
+    };
+  }
+  const modeResult = await findWorkspaceMode(cwd);
+  if (isWorkspaceMode(modeResult)) {
+    return addFolderToWorkspace({
+      cwd,
+      workspacePath: modeResult.workspacePath,
+      targetPath: options.targetPath,
+      folderId: options.folderId,
+      folderKind: options.folderKind ?? "app"
+    });
+  }
+  return addFolderToRepoSession({
+    cwd,
+    targetPath: options.targetPath,
+    folderId: options.folderId,
+    folderKind: options.folderKind,
+    session,
+    sessionPath,
+    now
+  });
+}
+async function addFolderToRepoSession(input) {
+  const folder = await resolveFolder({
+    cwd: input.cwd,
+    targetPath: input.targetPath,
+    id: input.folderId,
+    kind: input.folderKind
+  });
+  await ensureWeaveScaffold({ folder });
+  const result3 = addFolderToSession(input.session, folder, input.now);
+  await saveCurrentSession(result3.session, input.sessionPath);
+  if (!result3.added) {
+    return {
+      status: "already_exists",
+      message: `Folder already exists in current Weave session: ${result3.id}
+
+Path:
+  ${folder.path}`
+    };
+  }
+  return {
+    status: "added",
+    message: `Added folder to current Weave session: ${result3.id}
+
+Path:
+  ${folder.path}
+
+Next:
+  weave workspace`
+  };
+}
+async function addFolderToWorkspace(input) {
+  const workspacePath = await realpath4(input.workspacePath);
+  const metadata = await readWorkspaceMetadata(workspacePath);
+  if (!metadata) {
+    throw new Error(`Workspace metadata is missing or invalid: ${path6.join(workspacePath, ".weave", "workspace.yml")}`);
+  }
+  let repoAbsolutePath;
+  let relativePath;
+  let remote;
+  if (isGitUrl(input.targetPath)) {
+    const url = input.targetPath.trim();
+    const destName = repoNameFromUrl(url);
+    relativePath = destName;
+    repoAbsolutePath = path6.join(workspacePath, destName);
+    if (await pathExists(repoAbsolutePath)) {
+      throw new Error(`Destination already exists: ${repoAbsolutePath}`);
+    }
+    const existingId = findRegisteredRepoByPath(metadata, relativePath);
+    if (existingId) {
+      return workspaceAlreadyRegisteredMessage(existingId, relativePath, workspacePath);
+    }
+    try {
+      await cloneRepo(url, destName, workspacePath);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to clone repository: ${detail}`);
+    }
+    remote = url;
+  } else {
+    const candidate = path6.resolve(input.cwd, input.targetPath);
+    await assertDirectory(candidate);
+    if (await isInsideWorkspace(workspacePath, candidate)) {
+      repoAbsolutePath = await realpath4(candidate);
+      relativePath = relativeRepoPath(workspacePath, repoAbsolutePath);
+    } else {
+      const sourcePath = await realpath4(candidate);
+      const destName = path6.basename(sourcePath);
+      relativePath = destName;
+      repoAbsolutePath = path6.join(workspacePath, destName);
+      if (await pathExists(repoAbsolutePath)) {
+        throw new Error(`Destination already exists in workspace: ${repoAbsolutePath}`);
+      }
+      try {
+        await movePath(sourcePath, repoAbsolutePath);
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to adopt folder into workspace: ${detail}`);
+      }
+    }
+    const existingId = findRegisteredRepoByPath(metadata, relativePath);
+    if (existingId) {
+      return workspaceAlreadyRegisteredMessage(existingId, relativePath, workspacePath);
+    }
+    remote = await getGitRemote(repoAbsolutePath);
+  }
+  const id = defaultRepoId(relativePath, input.folderId);
+  await registerRepoIntoWorkspace({
+    workspacePath,
+    id,
+    relativePath,
+    kind: input.folderKind,
+    remote
+  });
+  const remoteText = remote ? `
+
+Remote:
+  ${remote}` : "";
+  return {
+    status: "added",
+    message: `Registered repo in workspace: ${id}
+
+Path:
+  ${relativePath}${remoteText}
+
+Workspace:
+  ${workspacePath}
+
+Next:
+  weave workspace`
+  };
+}
+function workspaceAlreadyRegisteredMessage(id, relativePath, workspacePath) {
+  return {
+    status: "already_exists",
+    message: `Repo already registered in workspace: ${id}
+
+Path:
+  ${relativePath}
+
+Workspace:
+  ${workspacePath}`
+  };
+}
+async function assertDirectory(targetPath) {
+  try {
+    const value = await stat2(targetPath);
+    if (!value.isDirectory()) {
+      throw new Error(`Expected a directory: ${targetPath}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Expected a directory")) {
+      throw error;
+    }
+    throw new Error(`Expected a directory: ${targetPath}`);
+  }
+}
+
+// src/commands/add.ts
+function addCommand() {
+  return new Command("add").description("Add a folder or git URL to the current Weave context (repo session or workspace registry).").argument("<path>", "folder path or git URL to add").option("--id <id>", "folder id").option("--kind <kind>", "folder kind", "app").action(async (targetPath, options) => {
+    const result3 = await addFolder({
+      cwd: process.cwd(),
+      targetPath,
+      folderId: options.id,
+      folderKind: options.kind
+    });
+    process.stdout.write(`${result3.message}
+`);
+    if (result3.status === "no_session") {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/agent.ts
+import { Command as Command2, InvalidArgumentError } from "commander";
+
+// src/lib/agent-skills.ts
+import { createHash as createHash2 } from "crypto";
+import { constants as constants2 } from "fs";
+import { access as access2, mkdir as mkdir2, readdir as readdir2, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { basename, dirname as dirname2, extname, join, relative } from "path";
+import { fileURLToPath } from "url";
+import YAML5 from "yaml";
+var manifestRelativePath = join(".weave", "agents.yml");
+async function listDefaultSkills(options = {}) {
+  const templatesDir = options.templatesDir ?? await findDefaultSkillsDir();
+  const entries = await readdir2(templatesDir, { withFileTypes: true });
+  const skills = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map((entry) => readDefaultSkill(entry.name, { templatesDir }))
+  );
+  return skills.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function readDefaultSkill(name, options = {}) {
+  validateSkillName(name);
+  const templatesDir = options.templatesDir ?? await findDefaultSkillsDir();
+  const sourcePath = join(templatesDir, name, "SKILL.md");
+  const content = await readFile5(sourcePath, "utf8").catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Unknown skill: ${name}`);
+    }
+    throw error;
+  });
+  const metadata = parseSkillFrontmatter(content, sourcePath);
+  if (metadata.name !== name) {
+    throw new Error(`Skill frontmatter name mismatch in ${sourcePath}: expected ${name}, got ${metadata.name}`);
+  }
+  return {
+    name: metadata.name,
+    description: metadata.description,
+    lastChangedIn: metadata.lastChangedIn,
+    sourcePath,
+    content,
+    hash: hashContent(content)
+  };
+}
+async function installAgentSkills(options) {
+  const manifest = await loadAgentsManifest(options.cwd);
+  const results = [];
+  for (const target of resolveAgentTargets(options.cwd, options.agent)) {
+    const artifacts = await defaultArtifactsForTarget(target, options);
+    for (const artifact of artifacts) {
+      results.push(await installArtifact(options.cwd, target.agent, artifact, manifest, options.now ?? /* @__PURE__ */ new Date()));
+    }
+  }
+  await saveAgentsManifest(options.cwd, manifest);
+  return summarize(results);
+}
+async function updateAgentSkills(options) {
+  const manifest = await loadAgentsManifest(options.cwd);
+  const results = [];
+  for (const target of resolveAgentTargets(options.cwd, options.agent)) {
+    const artifacts = await defaultArtifactsForTarget(target, options);
+    for (const artifact of artifacts) {
+      results.push(await updateArtifact(options.cwd, target.agent, artifact, manifest, options.now ?? /* @__PURE__ */ new Date()));
+    }
+  }
+  await saveAgentsManifest(options.cwd, manifest);
+  return summarize(results);
+}
+async function resetAgentSkills(options) {
+  const manifest = await loadAgentsManifest(options.cwd);
+  const results = [];
+  for (const target of resolveAgentTargets(options.cwd, options.agent)) {
+    const artifacts = await defaultArtifactsForTarget(target, options, options.skill);
+    for (const artifact of artifacts) {
+      results.push(await resetArtifact(options.cwd, target.agent, artifact, manifest, options.now ?? /* @__PURE__ */ new Date()));
+    }
+  }
+  await saveAgentsManifest(options.cwd, manifest);
+  return summarize(results);
+}
+async function diffAgentSkills(options) {
+  const chunks = [];
+  for (const target of resolveAgentTargets(options.cwd, options.agent)) {
+    const artifacts = await defaultArtifactsForTarget(target, options, options.skill);
+    for (const artifact of artifacts) {
+      if (!await pathExists(artifact.destination)) {
+        chunks.push(`Missing ${target.agent}/${artifact.kind}/${artifact.name} at ${relative(options.cwd, artifact.destination)}`);
+        continue;
+      }
+      const installed = await readFile5(artifact.destination, "utf8");
+      chunks.push(
+        formatFullFileDiff(
+          relative(options.cwd, artifact.destination),
+          `${artifact.kind}:${artifact.name}`,
+          installed,
+          artifact.content
+        )
+      );
+    }
+  }
+  return {
+    status: "ok",
+    message: chunks.join("\n")
+  };
+}
+async function defaultArtifactsForTarget(target, options, onlyName) {
+  const skills = onlyName ? [await readDefaultSkill(onlyName, { templatesDir: options.templatesDir })] : await listDefaultSkills({ templatesDir: options.templatesDir });
+  const artifacts = [];
+  for (const skill of skills) {
+    artifacts.push({
+      kind: "skill",
+      name: skill.name,
+      content: skill.content,
+      hash: skill.hash,
+      lastChangedIn: skill.lastChangedIn,
+      destination: installedSkillPath(target.skillsDir, skill.name)
+    });
+    const resources = await listDefaultSkillResources(skill);
+    for (const resource of resources) {
+      artifacts.push({
+        kind: "resource",
+        name: `${skill.name}/${resource.name}`,
+        content: resource.content,
+        hash: resource.hash,
+        lastChangedIn: skill.lastChangedIn,
+        destination: installedSkillResourcePath(target.skillsDir, skill.name, resource.name)
+      });
+    }
+  }
+  if (target.agent === "opencode" && target.commandsDir) {
+    const commands = onlyName ? await maybeReadDefaultOpencodeCommand(onlyName, { commandTemplatesDir: options.commandTemplatesDir }) : await listDefaultOpencodeCommands({ commandTemplatesDir: options.commandTemplatesDir });
+    for (const command of Array.isArray(commands) ? commands : commands ? [commands] : []) {
+      artifacts.push({
+        kind: "command",
+        name: command.name,
+        content: command.content,
+        hash: command.hash,
+        lastChangedIn: null,
+        destination: installedOpencodeCommandPath(target.commandsDir, command.name)
+      });
+    }
+  }
+  return artifacts;
+}
+async function listDefaultSkillResources(skill) {
+  const skillDir = dirname2(skill.sourcePath);
+  const entries = await readdir2(skillDir, { withFileTypes: true });
+  const resources = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name !== "SKILL.md").map(async (entry) => {
+      validateSkillResourceName(entry.name);
+      const sourcePath = join(skillDir, entry.name);
+      const content = await readFile5(sourcePath, "utf8");
+      return {
+        name: entry.name,
+        sourcePath,
+        content,
+        hash: hashContent(content)
+      };
+    })
+  );
+  return resources.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function listDefaultOpencodeCommands(options = {}) {
+  const commandTemplatesDir = options.commandTemplatesDir ?? await findDefaultOpencodeCommandsDir();
+  const entries = await readdir2(commandTemplatesDir, { withFileTypes: true }).catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+  const commands = await Promise.all(
+    entries.filter((entry) => entry.isFile() && extname(entry.name) === ".md").map((entry) => readDefaultOpencodeCommand(basename(entry.name, ".md"), { commandTemplatesDir }))
+  );
+  return commands.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function readDefaultOpencodeCommand(name, options = {}) {
+  validateSkillName(name);
+  const commandTemplatesDir = options.commandTemplatesDir ?? await findDefaultOpencodeCommandsDir();
+  const sourcePath = join(commandTemplatesDir, `${name}.md`);
+  const content = await readFile5(sourcePath, "utf8");
+  return {
+    name,
+    sourcePath,
+    content,
+    hash: hashContent(content)
+  };
+}
+async function maybeReadDefaultOpencodeCommand(name, options = {}) {
+  return readDefaultOpencodeCommand(name, options).catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  });
+}
+async function installArtifact(cwd, agent, artifact, manifest, now) {
+  const relativePath = relative(cwd, artifact.destination);
+  await ensureDir(dirname2(artifact.destination));
+  if (!await pathExists(artifact.destination)) {
+    await writeFile3(artifact.destination, artifact.content);
+    setManifestEntry(manifest, agent, artifact, relativePath, now);
+    return result(agent, artifact, relativePath, "installed", `Installed ${artifact.name} ${artifact.kind} for ${agent}`);
+  }
+  const currentHash = hashContent(await readFile5(artifact.destination, "utf8"));
+  const entry = getManifestEntry(manifest, agent, artifact.kind, artifact.name);
+  if (entry && currentHash !== entry.installed_hash) {
+    return result(agent, artifact, relativePath, "modified", `Skipped modified ${artifact.name} ${artifact.kind} for ${agent}`);
+  }
+  if (!entry && currentHash !== artifact.hash) {
+    return result(agent, artifact, relativePath, "modified", `Skipped existing ${artifact.name} ${artifact.kind} for ${agent}`);
+  }
+  if (entry && currentHash === entry.installed_hash && currentHash !== artifact.hash) {
+    await writeFile3(artifact.destination, artifact.content);
+    setManifestEntry(manifest, agent, artifact, relativePath, now);
+    return result(agent, artifact, relativePath, "updated", `Updated ${artifact.name} ${artifact.kind} for ${agent}`);
+  }
+  setManifestEntry(manifest, agent, artifact, relativePath, now);
+  return result(agent, artifact, relativePath, "unchanged", `${artifact.name} ${artifact.kind} already installed for ${agent}`);
+}
+async function updateArtifact(cwd, agent, artifact, manifest, now) {
+  const relativePath = relative(cwd, artifact.destination);
+  const entry = getManifestEntry(manifest, agent, artifact.kind, artifact.name);
+  if (!await pathExists(artifact.destination)) {
+    if (!entry && artifact.kind === "resource") {
+      await ensureDir(dirname2(artifact.destination));
+      await writeFile3(artifact.destination, artifact.content);
+      setManifestEntry(manifest, agent, artifact, relativePath, now);
+      return result(agent, artifact, relativePath, "installed", `Installed ${artifact.name} ${artifact.kind} for ${agent}`);
+    }
+    return result(agent, artifact, relativePath, "missing", `Missing ${artifact.name} ${artifact.kind} for ${agent}`);
+  }
+  const currentHash = hashContent(await readFile5(artifact.destination, "utf8"));
+  if (!entry || currentHash !== entry.installed_hash) {
+    return result(agent, artifact, relativePath, "modified", `Skipped modified ${artifact.name} ${artifact.kind} for ${agent}`);
+  }
+  if (currentHash === artifact.hash) {
+    setManifestEntry(manifest, agent, artifact, relativePath, now);
+    return result(agent, artifact, relativePath, "unchanged", `${artifact.name} ${artifact.kind} already up to date for ${agent}`);
+  }
+  await writeFile3(artifact.destination, artifact.content);
+  setManifestEntry(manifest, agent, artifact, relativePath, now);
+  return result(agent, artifact, relativePath, "updated", `Updated ${artifact.name} ${artifact.kind} for ${agent}`);
+}
+async function resetArtifact(cwd, agent, artifact, manifest, now) {
+  const relativePath = relative(cwd, artifact.destination);
+  await ensureDir(dirname2(artifact.destination));
+  await writeFile3(artifact.destination, artifact.content);
+  setManifestEntry(manifest, agent, artifact, relativePath, now);
+  return result(agent, artifact, relativePath, "reset", `Reset ${artifact.name} ${artifact.kind} for ${agent}`);
+}
+function setManifestEntry(manifest, agent, artifact, relativePath, now) {
+  manifest.installed[agent] ??= {};
+  const entries = manifest.installed[agent];
+  if (!entries) {
+    return;
+  }
+  const bucket = manifestBucketForKind(artifact.kind);
+  entries[bucket] ??= {};
+  entries[bucket][artifact.name] = {
+    path: relativePath,
+    source_hash: artifact.hash,
+    installed_hash: artifact.hash,
+    installed_at: now.toISOString(),
+    installed_from: artifact.lastChangedIn
+  };
+}
+function getManifestEntry(manifest, agent, kind, name) {
+  const entries = manifest.installed[agent];
+  return entries?.[manifestBucketForKind(kind)]?.[name];
+}
+function resolveAgentTargets(cwd, agent) {
+  switch (agent) {
+    case "codex":
+      return [{ agent, skillsDir: join(cwd, ".agents", "skills") }];
+    case "cursor":
+      return [{ agent, skillsDir: join(cwd, ".agents", "skills") }];
+    case "claude":
+      return [{ agent, skillsDir: join(cwd, ".claude", "skills") }];
+    case "opencode":
+      return [{ agent, skillsDir: join(cwd, ".agents", "skills"), commandsDir: join(cwd, ".opencode", "commands") }];
+    case "all":
+      return [
+        { agent: "codex", skillsDir: join(cwd, ".agents", "skills") },
+        { agent: "cursor", skillsDir: join(cwd, ".agents", "skills") },
+        { agent: "claude", skillsDir: join(cwd, ".claude", "skills") },
+        { agent: "opencode", skillsDir: join(cwd, ".agents", "skills"), commandsDir: join(cwd, ".opencode", "commands") }
+      ];
+    default:
+      throw new Error(`Unsupported agent: ${agent}`);
+  }
+}
+function installedSkillPath(skillsDir, skillName) {
+  return join(skillsDir, skillName, "SKILL.md");
+}
+function installedSkillResourcePath(skillsDir, skillName, resourceName) {
+  return join(skillsDir, skillName, resourceName);
+}
+function installedOpencodeCommandPath(commandsDir, commandName) {
+  return join(commandsDir, `${commandName}.md`);
+}
+async function loadAgentsManifest(cwd) {
+  const manifestPath = join(cwd, manifestRelativePath);
+  if (!await pathExists(manifestPath)) {
+    return { version: 1, installed: {} };
+  }
+  const parsed = YAML5.parse(await readFile5(manifestPath, "utf8"));
+  const installed = parsed?.installed ?? {};
+  for (const agent of Object.keys(installed)) {
+    const buckets = installed[agent];
+    if (!buckets) continue;
+    for (const bucket of ["skills", "commands", "resources"]) {
+      const entries = buckets[bucket];
+      if (!entries) continue;
+      for (const name of Object.keys(entries)) {
+        const entry = entries[name];
+        entries[name] = {
+          path: entry.path ?? "",
+          source_hash: entry.source_hash ?? "",
+          installed_hash: entry.installed_hash ?? "",
+          installed_at: entry.installed_at ?? "",
+          installed_from: entry.installed_from ?? null
+        };
+      }
+    }
+  }
+  return {
+    version: 1,
+    installed
+  };
+}
+async function saveAgentsManifest(cwd, manifest) {
+  const manifestPath = join(cwd, manifestRelativePath);
+  await mkdir2(dirname2(manifestPath), { recursive: true });
+  await writeFileAtomic(manifestPath, YAML5.stringify(manifest));
+}
+function parseSkillFrontmatter(content, sourcePath) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(content);
+  if (!match) {
+    throw new Error(`Missing frontmatter in ${sourcePath}`);
+  }
+  const metadata = YAML5.parse(match[1]);
+  if (!metadata.name || !metadata.description) {
+    throw new Error(`Skill frontmatter in ${sourcePath} must include name and description`);
+  }
+  if (metadata.last_changed_in === void 0 || metadata.last_changed_in === null || metadata.last_changed_in === "") {
+    throw new Error(
+      `Skill frontmatter in ${sourcePath} must include last_changed_in (the weave-it package version of the last skill change)`
+    );
+  }
+  return {
+    name: metadata.name,
+    description: metadata.description,
+    lastChangedIn: String(metadata.last_changed_in)
+  };
+}
+function formatFullFileDiff(installedPath, defaultName, installed, currentDefault) {
+  if (installed === currentDefault) {
+    return `No differences for ${installedPath}`;
+  }
+  const installedLines = splitLines(installed);
+  const defaultLines = splitLines(currentDefault);
+  return [
+    `--- installed:${installedPath}`,
+    `+++ default:${defaultName}`,
+    ...installedLines.map((line) => `-${line}`),
+    ...defaultLines.map((line) => `+${line}`)
+  ].join("\n");
+}
+function splitLines(value) {
+  return value.endsWith("\n") ? value.slice(0, -1).split("\n") : value.split("\n");
+}
+function result(agent, artifact, path14, status, message) {
+  return { agent, kind: artifact.kind, skill: artifact.name, path: path14, status, message };
+}
+function summarize(results) {
+  return {
+    status: "ok",
+    message: results.map((item) => item.message).join("\n"),
+    results
+  };
+}
+function hashContent(content) {
+  return `sha256:${createHash2("sha256").update(content).digest("hex")}`;
+}
+async function findDefaultSkillsDir() {
+  return join(await findTemplatesRoot(), "skills");
+}
+async function findDefaultOpencodeCommandsDir() {
+  return join(await findTemplatesRoot(), "opencode", "commands");
+}
+async function findTemplatesRoot() {
+  let current = dirname2(fileURLToPath(import.meta.url));
+  while (true) {
+    const candidate = join(current, "templates");
+    try {
+      await access2(candidate, constants2.R_OK);
+      return candidate;
+    } catch {
+      const parent = dirname2(current);
+      if (parent === current) {
+        throw new Error("Could not locate templates");
+      }
+      current = parent;
+    }
+  }
+}
+function validateSkillName(name) {
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    throw new Error(`Invalid skill name: ${name}`);
+  }
+}
+function validateSkillResourceName(name) {
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*\.md$/.test(name)) {
+    throw new Error(`Invalid skill resource name: ${name}`);
+  }
+}
+function manifestBucketForKind(kind) {
+  switch (kind) {
+    case "skill":
+      return "skills";
+    case "command":
+      return "commands";
+    case "resource":
+      return "resources";
+    default:
+      throw new Error(`Unsupported artifact kind: ${kind}`);
+  }
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/commands/agent.ts
+function agentCommand() {
+  const command = new Command2("agent").description("Install and manage agent skills.");
+  command.command("install").description("Install Weave skills for an agent.").argument("<agent>", "codex, cursor, claude, opencode, or all", parseAgentSelection).option("--json", "print machine-readable JSON").action(async (agent, options) => {
+    await runAction(async () => {
+      const result3 = await installAgentSkills({ cwd: process.cwd(), agent });
+      writeOperationResult(result3.message, result3.results, options.json ?? false);
+    });
+  });
+  command.command("update").description("Update installed Weave skills when they have not been modified.").argument("<agent>", "codex, cursor, claude, opencode, or all", parseAgentSelection).option("--json", "print machine-readable JSON").action(async (agent, options) => {
+    await runAction(async () => {
+      const result3 = await updateAgentSkills({ cwd: process.cwd(), agent });
+      writeOperationResult(result3.message, result3.results, options.json ?? false);
+    });
+  });
+  command.command("diff").description("Show differences between installed skills and current Weave defaults.").argument("<agent>", "codex, cursor, claude, opencode, or all", parseAgentSelection).argument("[skill]", "skill name").action(async (agent, skill) => {
+    await runAction(async () => {
+      const result3 = await diffAgentSkills({ cwd: process.cwd(), agent, skill });
+      process.stdout.write(`${result3.message}
+`);
+    });
+  });
+  command.command("reset").description("Overwrite installed skills with current Weave defaults.").argument("<agent>", "codex, cursor, claude, opencode, or all", parseAgentSelection).argument("[skill]", "skill name").option("--json", "print machine-readable JSON").action(async (agent, skill, options) => {
+    await runAction(async () => {
+      const result3 = await resetAgentSkills({ cwd: process.cwd(), agent, skill });
+      writeOperationResult(result3.message, result3.results, options.json ?? false);
+    });
+  });
+  return command;
+}
+function parseAgentSelection(value) {
+  if (value === "codex" || value === "cursor" || value === "claude" || value === "opencode" || value === "all") {
+    return value;
+  }
+  throw new InvalidArgumentError(`Unsupported agent: ${value}`);
+}
+function writeOperationResult(message, results, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${message}
+`);
+}
+async function runAction(action) {
+  try {
+    await action();
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/artifact.ts
+import { Command as Command3, InvalidArgumentError as InvalidArgumentError2 } from "commander";
+
+// src/lib/artifact-context.ts
+import path9 from "path";
+
+// src/lib/architecture-artifact.ts
+import { readFile as readFile6, readdir as readdir3, stat as stat3 } from "fs/promises";
+import path7 from "path";
+async function resolveArchitectureArtifact(changePath) {
+  const filePath = path7.join(changePath, "architecture.md");
+  const folderPath = path7.join(changePath, "architecture");
+  const fileExists = await pathExists(filePath);
+  const folderExists = await isDirectory(folderPath);
+  if (fileExists && folderExists) {
+    const folder = await readFolderArchitecture(folderPath);
+    const fileSubstantive = await hasSubstantiveMarkdown(filePath);
+    const substantive = fileSubstantive || folder.indexSubstantive || folder.substantiveFacetPaths.length > 0;
+    return {
+      status: "conflict",
+      filePath,
+      folderPath,
+      substantive,
+      fileSubstantive,
+      ...folder
+    };
+  }
+  if (fileExists) {
+    return {
+      status: "file",
+      path: filePath,
+      filePath,
+      folderPath,
+      substantive: await hasSubstantiveMarkdown(filePath)
+    };
+  }
+  if (folderExists) {
+    const folder = await readFolderArchitecture(folderPath);
+    return {
+      status: "folder",
+      filePath,
+      folderPath,
+      ...folder,
+      substantive: folder.indexSubstantive || folder.substantiveFacetPaths.length > 0,
+      partial: !folder.indexSubstantive && folder.substantiveFacetPaths.length > 0
+    };
+  }
+  return {
+    status: "missing",
+    filePath,
+    folderPath,
+    substantive: false
+  };
+}
+async function hasSubstantiveMarkdown(filePath) {
+  if (!await pathExists(filePath)) {
+    return false;
+  }
+  const content = await readFile6(filePath, "utf8");
+  const withoutFrontmatter = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+  const withoutScaffold = withoutFrontmatter.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    return trimmed && !trimmed.startsWith("#") && trimmed !== "Not ready";
+  }).join("\n").trim();
+  return withoutScaffold.length > 0;
+}
+async function readFolderArchitecture(folderPath) {
+  const indexPath = path7.join(folderPath, "index.md");
+  const entries = await readdir3(folderPath, { withFileTypes: true });
+  const markdownPaths = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path7.join(folderPath, entry.name)).sort((left, right) => left.localeCompare(right));
+  const facetPaths = markdownPaths.filter((filePath) => path7.basename(filePath) !== "index.md");
+  const substantiveFacetPaths = [];
+  for (const facetPath of facetPaths) {
+    if (await hasSubstantiveMarkdown(facetPath)) {
+      substantiveFacetPaths.push(facetPath);
+    }
+  }
+  return {
+    indexPath,
+    indexExists: await pathExists(indexPath),
+    indexSubstantive: await hasSubstantiveMarkdown(indexPath),
+    facetPaths,
+    substantiveFacetPaths
+  };
+}
+async function isDirectory(filePath) {
+  try {
+    return (await stat3(filePath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/artifact-metadata.ts
+import YAML6 from "yaml";
+var artifactNames = ["exploration", "prd", "architecture"];
+function isArtifactName(value) {
+  return Boolean(value && artifactNames.includes(value));
+}
+function artifactFileName(artifact) {
+  return artifact === "exploration" ? "exploration.md" : `${artifact}.md`;
+}
+function defaultArtifactOwner(artifact) {
+  return artifact === "architecture" ? "engineering" : "product";
+}
+function defaultArtifactSource(artifact) {
+  if (artifact === "exploration") {
+    return "discussion";
+  }
+  return artifact === "prd" ? "exploration.md" : "prd.md";
+}
+function artifactFrontmatter(options) {
+  const artifact = options.artifact;
+  const timestamp = options.now.toISOString();
+  return `---
+${YAML6.stringify({
+    artifact,
+    status: options.status ?? "draft",
+    owner: options.owner ?? defaultArtifactOwner(artifact),
+    created_at: timestamp,
+    updated_at: timestamp,
+    reviewed_at: null,
+    approved_at: null,
+    approved_by: null,
+    source: options.source ?? defaultArtifactSource(artifact)
+  })}---
+
+`;
+}
+
+// src/lib/changes.ts
+import { randomBytes } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { mkdir as mkdir3, readFile as readFile7, readdir as readdir4, writeFile as writeFile4 } from "fs/promises";
+import path8 from "path";
+import { promisify as promisify2 } from "util";
+import YAML7 from "yaml";
+var execFileAsync2 = promisify2(execFile2);
+var idChars = "abcdefghijklmnopqrstuvwxyz0123456789";
+var changeTypes = ["feat", "fix", "refactor", "docs", "test", "ci", "chore"];
+var changeStages = ["exploration", "prd", "architecture", "issues"];
+var storedStages = ["started", ...changeStages];
+var artifactSourceIds = ["exploration", "prd", "architecture", "discussion", "sessions", "codebase"];
+var knowledgeStatuses = ["pending", "stale", "updated", "none"];
+var ChangeCommandError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+  code;
+  details;
+};
+async function createChange(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const title = options.title.trim();
+  if (!title) {
+    throw new ChangeCommandError("missing_title", "Change title is required");
+  }
+  const targets = [await resolveTarget(options.cwd, options.sessionPath)];
+  const type = options.type ?? "feat";
+  const slug = normalizeChangeSlug(options.slug ?? title);
+  const id = await generateChangeId(targets, slug, now, options.randomId ?? randomChangeIdPart);
+  const branch = changeBranch(id);
+  await assertChangeMissing(targets, id);
+  const results = [];
+  for (const target of targets) {
+    const branchStatus = await ensureChangeBranch(target.path, branch);
+    await ensureWeaveScaffold({ folder: { path: target.path } });
+    const changePath = changeDir(target.path, id);
+    await mkdir3(changePath, { recursive: false });
+    await mkdir3(path8.join(changePath, "sessions"));
+    await writeFile4(path8.join(changePath, "status.yml"), statusTemplate({ id, slug, title, type, branch, now }));
+    if (type === "feat") {
+      await writeFile4(path8.join(changePath, "exploration.md"), explorationTemplate(title, title, now));
+    }
+    results.push({ path: target.path, changePath, branch, branchStatus, current: true });
+  }
+  await saveCurrentForTargets(
+    options.sessionPath,
+    results.map((target) => ({
+      root: target.path,
+      changeId: id,
+      changePath: target.changePath,
+      branch,
+      artifact: type === "feat" ? "exploration" : void 0
+    })),
+    now
+  );
+  return summarizeChangeOperation({ id, slug, title, type, branch, targets: results, verb: "Created" });
+}
+async function listChanges(options) {
+  const session = await loadCurrentSession(options.sessionPath ?? defaultSessionPath());
+  const targets = [await resolveTarget(options.cwd, options.sessionPath)];
+  const summaries = [];
+  for (const target of targets) {
+    const activeId = activeChangeForTarget(session, target)?.id;
+    const changes = await readChanges(target.path, activeId);
+    summaries.push({ id: target.id, name: target.name, path: target.path, changes });
+  }
+  return {
+    status: "ok",
+    targets: summaries,
+    message: formatListMessage(summaries)
+  };
+}
+async function currentChange(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(sessionPath, now);
+  const targets = [await resolveTarget(options.cwd, sessionPath)];
+  const results = [];
+  let mutated = false;
+  for (const target of targets) {
+    const context = await currentContextForTarget(session, target, now, { saveInferred: true });
+    mutated ||= context.saved;
+    results.push(context);
+  }
+  if (mutated) {
+    await saveCurrentSession(session, sessionPath);
+  }
+  return {
+    status: "ok",
+    targets: results,
+    message: formatCurrentMessage(results)
+  };
+}
+async function statusChange(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(sessionPath, now);
+  const targets = [await resolveTarget(options.cwd, sessionPath)];
+  const results = [];
+  let mutated = false;
+  for (const target of targets) {
+    if (options.change) {
+      const changes = await readChanges(target.path, activeChangeForTarget(session, target)?.id);
+      const change = resolveChangeReference(changes, options.change);
+      const branch = await currentBranch2(target.path);
+      results.push({
+        id: target.id,
+        name: target.name,
+        path: target.path,
+        active: change.active,
+        source: "explicit",
+        saved: false,
+        change,
+        branch,
+        branchMatch: branchMatch(branch, change.branch, await findGitRoot(target.path))
+      });
+      continue;
+    }
+    const context = await currentContextForTarget(session, target, now, { saveInferred: true });
+    mutated ||= context.saved;
+    results.push({
+      id: context.id,
+      name: context.name,
+      path: context.path,
+      active: Boolean(context.current),
+      source: context.source,
+      saved: context.saved,
+      change: context.current,
+      branch: context.branch,
+      branchMatch: context.branchMatch,
+      mismatch: context.mismatch
+    });
+  }
+  if (mutated) {
+    await saveCurrentSession(session, sessionPath);
+  }
+  return {
+    status: "ok",
+    targets: results,
+    message: formatStatusMessage(results)
+  };
+}
+async function activeChangeContext(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(sessionPath, now);
+  const context = await resolveChangeContext(options.cwd, sessionPath);
+  if (!context) {
+    throw new ChangeCommandError("no_weave_context", "No Weave context found. Run `weave init` first.");
+  }
+  const target = {
+    id: context.folderId,
+    name: context.folderName,
+    path: context.rootPath
+  };
+  const current = await currentContextForTarget(session, target, now, { saveInferred: true });
+  if (current.saved) {
+    await saveCurrentSession(session, sessionPath);
+  }
+  if (!current.current) {
+    throw new ChangeCommandError("no_current_change", "No active Weave change found. Run `weave change new` or `weave change switch` first.");
+  }
+  return {
+    target: { id: target.id, name: target.name, path: target.path },
+    change: current.current,
+    mode: context.mode,
+    branch: current.branch,
+    branchMatch: current.branchMatch
+  };
+}
+async function switchChange(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const target = await resolveTarget(options.cwd, options.sessionPath);
+  await assertCleanGitTargets([target]);
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(sessionPath, now);
+  const changes = await readChanges(target.path, activeChangeForTarget(session, target)?.id);
+  const change = resolveChangeReference(changes, options.change);
+  const branchStatus = await ensureChangeBranch(target.path, change.branch);
+  setCurrentChangeForPath(
+    session,
+    target.path,
+    { id: change.id, path: change.path, branch: change.branch },
+    now
+  );
+  const activeArtifact = activeArtifactForTarget(session, target);
+  if (activeArtifact && activeArtifact.change_id !== change.id) {
+    clearCurrentArtifactForPath(session, target.path, now);
+  }
+  await saveCurrentSession(session, sessionPath);
+  return {
+    status: "ok",
+    change: { ...change, active: true },
+    branchStatus,
+    target: { id: target.id, name: target.name, path: target.path },
+    message: [
+      `Switched change: ${change.id}`,
+      "",
+      `Title: ${change.title}`,
+      `Type: ${change.type}`,
+      `Stage: ${change.stage}`,
+      `Branch: ${change.branch} (${formatBranchStatus(branchStatus)})`,
+      `Path: ${change.path}`,
+      "Current: yes"
+    ].join("\n")
+  };
+}
+async function progressChange(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(sessionPath, now);
+  const target = await resolveTarget(options.cwd, sessionPath);
+  const context = await currentContextForTarget(session, target, now, { saveInferred: true });
+  if (context.saved) {
+    await saveCurrentSession(session, sessionPath);
+  }
+  if (!context.current) {
+    throw new ChangeCommandError("no_current_change", "No active Weave change found. Run `weave change new` or `weave change switch` first.");
+  }
+  const statusPath = path8.join(context.current.changePath, "status.yml");
+  const raw = await readStatusFile(statusPath);
+  const existing = await readChangeMetadata(context.current.changePath, context.current.id);
+  const sourceResolution = await resolveProgressSources(options, context.current.changePath);
+  const nextStage = maxStage([existing.stage, options.stage]);
+  const artifacts = {
+    ...existing.artifacts,
+    [options.stage]: {
+      sources: sourceResolution.sources,
+      updated_at: now.toISOString()
+    }
+  };
+  const stale = { ...existing.stale };
+  delete stale[options.stage];
+  const invalidatedAt = now.toISOString();
+  const computedDependents = transitiveDependents(options.stage, artifacts);
+  const propagationTargets = resolveStalePropagationTargets({
+    computed: computedDependents,
+    noInvalidate: options.noInvalidate ?? false,
+    invalidateOnly: options.invalidateOnly
+  });
+  for (const stage of propagationTargets) {
+    stale[stage] = {
+      invalidated_by: options.stage,
+      invalidated_at: invalidatedAt
+    };
+  }
+  const nextStatus = {
+    ...raw,
+    stage: nextStage,
+    artifacts,
+    updated_at: invalidatedAt
+  };
+  if (Object.keys(stale).length > 0) {
+    Object.assign(nextStatus, { stale });
+  } else {
+    delete nextStatus.stale;
+  }
+  const knowledge = staleKnowledgeFromProgress(raw.knowledge, existing.knowledge, options.stage, invalidatedAt);
+  if (knowledge) {
+    Object.assign(nextStatus, { knowledge });
+  }
+  await writeFile4(statusPath, YAML7.stringify(nextStatus));
+  const updated = await readChangeMetadata(context.current.changePath, context.current.id);
+  const change = {
+    ...updated,
+    path: context.current.path,
+    changePath: context.current.changePath,
+    active: true
+  };
+  return {
+    status: "ok",
+    target: { id: target.id, name: target.name, path: target.path },
+    change,
+    progressed: options.stage,
+    sources: sourceResolution.sources,
+    note: sourceResolution.note,
+    message: formatProgressMessage({ id: target.id, name: target.name, path: target.path }, change, options.stage, sourceResolution.note)
+  };
+}
+async function clearChangeStaleness(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const session = await loadOrCreateSession(
+    options.sessionPath ?? defaultSessionPath(),
+    now
+  );
+  const target = await resolveTarget(options.cwd, options.sessionPath);
+  const context = await currentContextForTarget(session, target, now, { saveInferred: true });
+  if (context.saved) {
+    await saveCurrentSession(session, options.sessionPath ?? defaultSessionPath());
+  }
+  if (!context.current) {
+    throw new ChangeCommandError(
+      "no_current_change",
+      "No active Weave change found. Run `weave change new` or `weave change switch` first."
+    );
+  }
+  const statusPath = path8.join(context.current.changePath, "status.yml");
+  const raw = await readStatusFile(statusPath);
+  const existing = await readChangeMetadata(context.current.changePath, context.current.id);
+  const currentStale = existing.stale[options.lane];
+  if (!currentStale) {
+    throw new ChangeCommandError(
+      "lane_not_stale",
+      `Lane "${options.lane}" is not currently marked stale; nothing to clear.`,
+      { lane: options.lane }
+    );
+  }
+  const nextStale = { ...existing.stale };
+  delete nextStale[options.lane];
+  const historyEntry = {
+    lane: options.lane,
+    invalidated_by: currentStale.invalidated_by,
+    invalidated_at: currentStale.invalidated_at,
+    cleared_at: now.toISOString(),
+    reason: options.reason && options.reason.trim().length > 0 ? options.reason.trim() : null
+  };
+  const nextHistory = [...existing.stale_history, historyEntry];
+  const nextStatus = {
+    ...raw,
+    updated_at: now.toISOString(),
+    stale_history: nextHistory
+  };
+  if (Object.keys(nextStale).length > 0) {
+    nextStatus.stale = nextStale;
+  } else {
+    delete nextStatus.stale;
+  }
+  await writeFile4(statusPath, YAML7.stringify(nextStatus));
+  const updated = await readChangeMetadata(context.current.changePath, context.current.id);
+  const change = {
+    ...updated,
+    path: context.current.path,
+    changePath: context.current.changePath,
+    active: true
+  };
+  return {
+    status: "ok",
+    target: { id: target.id, name: target.name, path: target.path },
+    change,
+    cleared: options.lane,
+    history_entry: historyEntry,
+    message: `Cleared stale flag for ${options.lane} (was invalidated by ${currentStale.invalidated_by}).${historyEntry.reason ? ` Reason: ${historyEntry.reason}` : ""}`
+  };
+}
+async function knowledgeChange(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(sessionPath, now);
+  const target = await resolveTarget(options.cwd, sessionPath);
+  const context = await currentContextForTarget(session, target, now, { saveInferred: true });
+  if (context.saved) {
+    await saveCurrentSession(session, sessionPath);
+  }
+  if (!context.current) {
+    throw new ChangeCommandError("no_current_change", "No active Weave change found. Run `weave change new` or `weave change switch` first.");
+  }
+  const invalidatedBy = options.invalidatedBy ? normalizeKnowledgeInvalidationSource(options.invalidatedBy) : void 0;
+  const statusPath = path8.join(context.current.changePath, "status.yml");
+  const raw = await readStatusFile(statusPath);
+  const existing = await readChangeMetadata(context.current.changePath, context.current.id);
+  const knowledge = mergeKnowledgeMetadata(raw.knowledge, existing.knowledge, {
+    status: options.status,
+    updatedAt: now.toISOString(),
+    domains: options.domains,
+    shared: options.shared,
+    files: options.files,
+    delta: options.delta,
+    reason: options.reason,
+    invalidatedBy
+  });
+  const nextStatus = {
+    ...raw,
+    knowledge,
+    updated_at: now.toISOString()
+  };
+  await writeFile4(statusPath, YAML7.stringify(nextStatus));
+  const updated = await readChangeMetadata(context.current.changePath, context.current.id);
+  const change = {
+    ...updated,
+    path: context.current.path,
+    changePath: context.current.changePath,
+    active: true
+  };
+  if (!change.knowledge) {
+    throw new ChangeCommandError("invalid_knowledge_status", "Knowledge status could not be recorded");
+  }
+  return {
+    status: "ok",
+    target: { id: target.id, name: target.name, path: target.path },
+    change,
+    knowledge: change.knowledge,
+    message: formatKnowledgeMessage({ id: target.id, name: target.name, path: target.path }, change)
+  };
+}
+function normalizeChangeSlug(value) {
+  const slug = slugify(value, "change");
+  return slug.split("-").filter(Boolean).slice(0, 6).join("-") || "change";
+}
+async function generateChangeId(targets, slug, now, randomId) {
+  const date = formatDatePrefix(now);
+  for (let index = 0; index < 20; index += 1) {
+    const id = `${date}-${randomId()}-${slug}`;
+    const exists = await Promise.all(targets.map((target) => pathExists(changeDir(target.path, id))));
+    if (!exists.some(Boolean)) {
+      return id;
+    }
+  }
+  throw new ChangeCommandError("id_collision", "Could not generate a unique change id");
+}
+function formatDatePrefix(now) {
+  const year = String(now.getFullYear()).slice(-2);
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}${month}${day}`;
+}
+function randomChangeIdPart() {
+  const bytes = randomBytes(4);
+  return Array.from(bytes, (byte) => idChars[byte % idChars.length]).join("");
+}
+function changeBranch(changeId) {
+  return `change/${changeId}`;
+}
+function changeDir(root, changeId) {
+  return path8.join(root, "wiki", "changes", changeId);
+}
+async function assertChangeMissing(targets, changeId) {
+  const existing = [];
+  for (const target of targets) {
+    const targetChangePath = changeDir(target.path, changeId);
+    if (await pathExists(targetChangePath)) {
+      existing.push(targetChangePath);
+    }
+  }
+  if (existing.length > 0) {
+    throw new ChangeCommandError(
+      "change_exists",
+      `Change already exists:
+${existing.map((item) => `  ${item}`).join("\n")}`,
+      { existing }
+    );
+  }
+}
+async function resolveTarget(cwd, sessionPath) {
+  const context = await resolveChangeContext(cwd, sessionPath ?? defaultSessionPath());
+  if (!context) {
+    throw new ChangeCommandError("no_weave_context", "No Weave context found. Run `weave init` first.");
+  }
+  return {
+    id: context.folderId,
+    name: context.folderName,
+    path: context.rootPath
+  };
+}
+async function readChanges(root, activeId) {
+  const changesRoot = path8.join(root, "wiki", "changes");
+  const entries = await readdir4(changesRoot, { withFileTypes: true }).catch((error) => {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+  const changes = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+      const changePath = path8.join(changesRoot, entry.name);
+      const metadata = await readChangeMetadata(changePath, entry.name);
+      return {
+        ...metadata,
+        path: path8.join("wiki", "changes", metadata.id),
+        changePath,
+        active: metadata.id === activeId
+      };
+    })
+  );
+  return changes.sort(compareChangesNewestFirst);
+}
+async function readChangeMetadata(changePath, fallbackId) {
+  const statusPath = path8.join(changePath, "status.yml");
+  const parsed = await pathExists(statusPath) ? await readStatusFile(statusPath) : {};
+  const id = typeof parsed?.id === "string" ? parsed.id : fallbackId;
+  const slug = typeof parsed?.slug === "string" ? parsed.slug : id.split("-").slice(2).join("-");
+  const title = typeof parsed?.title === "string" ? parsed.title : titleFromSlug(slug);
+  const type = isChangeType(parsed?.type) ? parsed.type : "feat";
+  const branch = typeof parsed?.branch === "string" ? parsed.branch : changeBranch(id);
+  const stage = isStoredChangeStage(parsed?.stage) ? parsed.stage : "exploration";
+  return {
+    id,
+    slug,
+    title,
+    type,
+    stage,
+    stale: parseStaleLanes(parsed?.stale),
+    stale_history: parseStaleHistory(parsed?.stale_history),
+    artifacts: parseArtifactsMetadata(parsed?.artifacts),
+    knowledge: parseKnowledgeMetadata(parsed?.knowledge),
+    branch,
+    created_at: typeof parsed?.created_at === "string" ? parsed.created_at : void 0,
+    updated_at: typeof parsed?.updated_at === "string" ? parsed.updated_at : void 0
+  };
+}
+async function readStatusFile(statusPath) {
+  const parsed = YAML7.parse(await readFile7(statusPath, "utf8"));
+  return isRecord(parsed) ? parsed : {};
+}
+function parseStaleHistory(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const lane = entry.lane;
+    const clearedAt = entry.cleared_at;
+    if (!isChangeStage(lane) || typeof clearedAt !== "string") continue;
+    out.push({
+      lane,
+      invalidated_by: isChangeStage(entry.invalidated_by) ? entry.invalidated_by : null,
+      invalidated_at: typeof entry.invalidated_at === "string" ? entry.invalidated_at : null,
+      cleared_at: clearedAt,
+      reason: typeof entry.reason === "string" ? entry.reason : null
+    });
+  }
+  return out;
+}
+function parseStaleLanes(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const stale = {};
+  for (const [lane, metadata] of Object.entries(value)) {
+    if (!isChangeStage(lane) || !isRecord(metadata)) {
+      continue;
+    }
+    const invalidatedBy = metadata.invalidated_by;
+    const invalidatedAt = metadata.invalidated_at;
+    if (!isChangeStage(invalidatedBy) || typeof invalidatedAt !== "string") {
+      continue;
+    }
+    stale[lane] = {
+      invalidated_by: invalidatedBy,
+      invalidated_at: invalidatedAt
+    };
+  }
+  return stale;
+}
+function parseArtifactsMetadata(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const artifacts = {};
+  for (const [lane, metadata] of Object.entries(value)) {
+    if (!isChangeStage(lane) || !isRecord(metadata)) {
+      continue;
+    }
+    const updatedAt = metadata.updated_at;
+    if (typeof updatedAt !== "string") {
+      continue;
+    }
+    artifacts[lane] = {
+      sources: parseArtifactSources(metadata.sources),
+      updated_at: updatedAt
+    };
+  }
+  return artifacts;
+}
+function parseArtifactSources(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return dedupeSources(value.filter(isArtifactSourceId));
+}
+function parseKnowledgeMetadata(value) {
+  if (!isRecord(value) || !isKnowledgeStatus(value.status) || typeof value.updated_at !== "string") {
+    return void 0;
+  }
+  const invalidatedBy = value.invalidated_by;
+  const invalidatedAt = value.invalidated_at;
+  const knowledge = {
+    status: value.status,
+    updated_at: value.updated_at,
+    domains: parseStringList(value.domains),
+    shared: parseStringList(value.shared),
+    files: parseStringList(value.files)
+  };
+  if (typeof value.delta === "string") {
+    knowledge.delta = value.delta;
+  }
+  if (typeof value.reason === "string") {
+    knowledge.reason = value.reason;
+  }
+  if (isKnowledgeInvalidationSource(invalidatedBy) && typeof invalidatedAt === "string") {
+    knowledge.invalidated_by = invalidatedBy;
+    knowledge.invalidated_at = invalidatedAt;
+  }
+  return knowledge;
+}
+function parseStringList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return dedupeStrings(value.filter((item) => typeof item === "string" && item.trim().length > 0));
+}
+function dedupeStrings(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function mergeKnowledgeMetadata(rawKnowledge, existing, update) {
+  const base = isRecord(rawKnowledge) ? { ...rawKnowledge } : {};
+  const currentDomains = existing?.domains ?? parseStringList(base.domains);
+  const currentShared = existing?.shared ?? parseStringList(base.shared);
+  const currentFiles = existing?.files ?? parseStringList(base.files);
+  const next = {
+    ...base,
+    status: update.status,
+    updated_at: update.updatedAt,
+    domains: update.domains ? dedupeStrings(update.domains) : currentDomains,
+    shared: update.shared ? dedupeStrings(update.shared) : currentShared,
+    files: update.files ? dedupeStrings(update.files) : currentFiles
+  };
+  if (update.delta !== void 0) {
+    Object.assign(next, { delta: update.delta });
+  } else if (existing?.delta) {
+    Object.assign(next, { delta: existing.delta });
+  }
+  if (update.reason !== void 0) {
+    Object.assign(next, { reason: update.reason });
+  } else if (existing?.reason) {
+    Object.assign(next, { reason: existing.reason });
+  }
+  if (update.status === "stale") {
+    Object.assign(next, { invalidated_at: update.updatedAt });
+    if (update.invalidatedBy) {
+      Object.assign(next, { invalidated_by: update.invalidatedBy });
+    } else if (existing?.invalidated_by) {
+      Object.assign(next, { invalidated_by: existing.invalidated_by });
+    }
+  } else {
+    delete next.invalidated_by;
+    delete next.invalidated_at;
+  }
+  return parseKnowledgeMetadata(next) ?? {
+    status: update.status,
+    updated_at: update.updatedAt,
+    domains: update.domains ? dedupeStrings(update.domains) : currentDomains,
+    shared: update.shared ? dedupeStrings(update.shared) : currentShared,
+    files: update.files ? dedupeStrings(update.files) : currentFiles
+  };
+}
+function staleKnowledgeFromProgress(rawKnowledge, existing, invalidatedBy, invalidatedAt) {
+  if (!existing || existing.status !== "updated" && existing.status !== "none") {
+    return existing;
+  }
+  return mergeKnowledgeMetadata(rawKnowledge, existing, {
+    status: "stale",
+    updatedAt: invalidatedAt,
+    invalidatedBy,
+    reason: `${invalidatedBy} changed after knowledge was marked ${existing.status}.`
+  });
+}
+async function resolveProgressSources(options, changePath) {
+  const requested = options.sources ?? [];
+  const sources = dedupeSources(requested.map((source) => normalizeArtifactSourceId(source)));
+  if (sources.length > 0) {
+    return { sources };
+  }
+  if (options.stage === "issues" && (await resolveArchitectureArtifact(changePath)).substantive) {
+    return { sources: ["architecture"] };
+  }
+  return {
+    sources,
+    note: `No sources recorded for ${options.stage}; downstream stale invalidation will only use explicitly recorded dependencies.`
+  };
+}
+function normalizeArtifactSourceId(value) {
+  if (isArtifactSourceId(value)) {
+    return value;
+  }
+  throw new ChangeCommandError(
+    "unsupported_source",
+    `Unsupported artifact source: ${value}. Expected ${artifactSourceIds.join(", ")}`,
+    { source: value, supported: artifactSourceIds }
+  );
+}
+function dedupeSources(sources) {
+  return [...new Set(sources)];
+}
+function resolveStalePropagationTargets(input) {
+  if (input.noInvalidate && input.invalidateOnly && input.invalidateOnly.length > 0) {
+    throw new ChangeCommandError(
+      "conflicting_stale_flags",
+      "Use either --no-invalidate or --invalidate=<list>, not both."
+    );
+  }
+  if (input.noInvalidate) {
+    return [];
+  }
+  if (input.invalidateOnly && input.invalidateOnly.length > 0) {
+    const computed = new Set(input.computed);
+    const intersection = [];
+    const unknown = [];
+    for (const candidate of input.invalidateOnly) {
+      if (computed.has(candidate)) {
+        intersection.push(candidate);
+      } else {
+        unknown.push(candidate);
+      }
+    }
+    if (unknown.length > 0) {
+      throw new ChangeCommandError(
+        "invalid_invalidate_target",
+        `Cannot invalidate lanes that are not transitive dependents of the progressed lane: ${unknown.join(", ")}`,
+        { unknown, computedDependents: input.computed }
+      );
+    }
+    return intersection;
+  }
+  return input.computed;
+}
+function transitiveDependents(source, artifacts) {
+  const dependents = /* @__PURE__ */ new Set();
+  const queue = [source];
+  for (let index = 0; index < queue.length; index += 1) {
+    const current = queue[index];
+    for (const candidate of changeStages) {
+      if (candidate === source || dependents.has(candidate)) {
+        continue;
+      }
+      const candidateSources = artifacts[candidate]?.sources ?? [];
+      if (candidateSources.some((candidateSource) => candidateSource === current)) {
+        dependents.add(candidate);
+        queue.push(candidate);
+      }
+    }
+  }
+  return changeStages.filter((stage) => dependents.has(stage));
+}
+function compareChangesNewestFirst(left, right) {
+  const leftTime = left.created_at ?? left.id;
+  const rightTime = right.created_at ?? right.id;
+  return rightTime.localeCompare(leftTime);
+}
+function resolveChangeReference(changes, value) {
+  const ref = value.trim().toLowerCase();
+  const matches = changes.filter((change) => {
+    const token = change.id.split("-")[1];
+    return change.id.toLowerCase() === ref || token === ref || change.slug.toLowerCase().includes(ref) || change.title.toLowerCase().includes(ref);
+  });
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length === 0) {
+    throw new ChangeCommandError("change_not_found", `No matching change found: ${value}`);
+  }
+  throw new ChangeCommandError(
+    "ambiguous_change",
+    `Ambiguous change reference: ${value}
+${matches.map((change) => `  ${change.id} - ${change.title}`).join("\n")}`,
+    { candidates: matches.map((change) => ({ id: change.id, title: change.title, type: change.type, stage: change.stage })) }
+  );
+}
+async function currentContextForTarget(session, target, now, options) {
+  const saved = activeChangeForTarget(session, target);
+  const changes = await readChanges(target.path, saved?.id);
+  const branch = await currentBranch2(target.path);
+  const inferred = branch ? inferChangeFromBranch(changes, branch) : void 0;
+  if (saved && inferred && saved.id !== inferred.id) {
+    const savedChange = changes.find((change) => change.id === saved.id);
+    return {
+      id: target.id,
+      name: target.name,
+      path: target.path,
+      source: "session",
+      saved: false,
+      current: savedChange ? { ...savedChange, active: true } : void 0,
+      branch,
+      branchMatch: "mismatch",
+      mismatch: { session: saved, branch: inferred }
+    };
+  }
+  if (saved) {
+    const current = changes.find((change) => change.id === saved.id);
+    return {
+      id: target.id,
+      name: target.name,
+      path: target.path,
+      source: "session",
+      saved: false,
+      current: current ? { ...current, active: true } : void 0,
+      branch,
+      branchMatch: current ? branchMatch(branch, current.branch, await findGitRoot(target.path)) : "unknown"
+    };
+  }
+  if (inferred && options.saveInferred) {
+    setCurrentChangeForPath(session, target.path, { id: inferred.id, path: inferred.path, branch: inferred.branch }, now);
+    return {
+      id: target.id,
+      name: target.name,
+      path: target.path,
+      source: "inferred_saved",
+      saved: true,
+      current: { ...inferred, active: true },
+      branch,
+      branchMatch: "match"
+    };
+  }
+  return {
+    id: target.id,
+    name: target.name,
+    path: target.path,
+    source: "none",
+    saved: false,
+    branch,
+    branchMatch: branch ? "unknown" : await findGitRoot(target.path) ? "unknown" : "not_git"
+  };
+}
+function activeChangeForTarget(session, target) {
+  const id = target.id ?? (session ? findFolderByPath(session, target.path) : void 0);
+  return id ? session?.folders[id]?.current_change : void 0;
+}
+function activeArtifactForTarget(session, target) {
+  const id = target.id ?? (session ? findFolderByPath(session, target.path) : void 0);
+  return id ? session?.folders[id]?.current_artifact : void 0;
+}
+function inferChangeFromBranch(changes, branch) {
+  if (!branch.startsWith("change/")) {
+    return void 0;
+  }
+  const id = branch.slice("change/".length);
+  return changes.find((change) => change.id === id);
+}
+async function saveCurrentForTargets(sessionPath, updates, now) {
+  const pathToSession = sessionPath ?? defaultSessionPath();
+  const session = await loadOrCreateSession(pathToSession, now);
+  for (const update of updates) {
+    const changeRelativePath = path8.relative(update.root, update.changePath);
+    setCurrentChangeForPath(
+      session,
+      update.root,
+      {
+        id: update.changeId,
+        path: changeRelativePath,
+        branch: update.branch
+      },
+      now
+    );
+    if (update.artifact) {
+      setCurrentArtifactForPath(
+        session,
+        update.root,
+        {
+          artifact: update.artifact,
+          change_id: update.changeId,
+          path: artifactPath(changeRelativePath, update.artifact)
+        },
+        now
+      );
+    }
+  }
+  await saveCurrentSession(session, pathToSession);
+}
+function artifactPath(changePath, artifact) {
+  return path8.join(changePath, artifactFileName(artifact));
+}
+async function loadOrCreateSession(sessionPath, now) {
+  return await loadCurrentSession(sessionPath) ?? {
+    version: 1,
+    updated_at: now.toISOString(),
+    folders: {}
+  };
+}
+function statusTemplate(input) {
+  return YAML7.stringify({
+    version: 1,
+    id: input.id,
+    slug: input.slug,
+    title: input.title,
+    type: input.type,
+    stage: input.type === "feat" ? "exploration" : "started",
+    branch: input.branch,
+    created_at: input.now.toISOString(),
+    updated_at: input.now.toISOString()
+  });
+}
+function explorationTemplate(title, topic, now) {
+  return `${artifactFrontmatter({ artifact: "exploration", now })}# ${titleFromSlug(slugify(title, "change")) || title}
+
+## Topic
+
+${topic}
+
+## Current Understanding
+
+## Open Questions
+
+## Decisions
+
+## Scenarios
+
+## Existing Behavior
+
+## PRD Readiness
+
+Not ready
+`;
+}
+async function ensureChangeBranch(cwd, branch) {
+  const gitRoot = await findGitRoot(cwd);
+  if (!gitRoot) {
+    return "skipped_not_git";
+  }
+  const current = await git2(["branch", "--show-current"], gitRoot);
+  if (current === branch) {
+    return "already_active";
+  }
+  const exists = await git2(["rev-parse", "--verify", `refs/heads/${branch}`], gitRoot);
+  if (exists) {
+    await gitRequired(["checkout", branch], gitRoot);
+    return "checked_out";
+  }
+  await gitRequired(["checkout", "-b", branch], gitRoot);
+  return "created";
+}
+async function assertCleanGitTargets(targets) {
+  for (const target of targets) {
+    const gitRoot = await findGitRoot(target.path);
+    if (!gitRoot) {
+      continue;
+    }
+    const dirty = await git2(["status", "--porcelain"], gitRoot);
+    if (dirty) {
+      throw new ChangeCommandError("dirty_worktree", `Uncommitted changes in ${target.path}. Commit, stash, or clean them before switching change context.`, {
+        path: target.path
+      });
+    }
+  }
+}
+async function currentBranch2(cwd) {
+  const gitRoot = await findGitRoot(cwd);
+  if (!gitRoot) {
+    return void 0;
+  }
+  return git2(["branch", "--show-current"], gitRoot);
+}
+function branchMatch(branch, expected, gitRoot) {
+  if (!gitRoot) {
+    return "not_git";
+  }
+  if (!branch) {
+    return "unknown";
+  }
+  return branch === expected ? "match" : "mismatch";
+}
+async function git2(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync2("git", args, { cwd });
+    const value = stdout.trim();
+    return value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function gitRequired(args, cwd) {
+  await execFileAsync2("git", args, { cwd });
+}
+function summarizeChangeOperation(input) {
+  const lines = [
+    `${input.verb} change: ${input.id}`,
+    "",
+    `Title: ${input.title}`,
+    `Type: ${input.type}`,
+    `Branch: ${input.branch}`,
+    "",
+    "Targets:",
+    ...input.targets.map((target) => `  ${target.path} (${formatBranchStatus(target.branchStatus)}, current)`)
+  ];
+  return {
+    status: "ok",
+    id: input.id,
+    slug: input.slug,
+    title: input.title,
+    type: input.type,
+    branch: input.branch,
+    targets: input.targets,
+    message: lines.join("\n")
+  };
+}
+function formatListMessage(targets) {
+  if (targets.length === 0) {
+    return "No workspace folders found.";
+  }
+  return targets.map((target) => {
+    const lines = [`Changes in ${target.name ?? target.path}`];
+    if (target.changes.length === 0) {
+      lines.push("  No changes found.");
+    } else {
+      lines.push(
+        ...target.changes.map((change) => `${change.active ? "*" : " "} ${change.id}  ${change.type}  ${change.stage}  ${change.title}`)
+      );
+    }
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function formatCurrentMessage(targets) {
+  if (targets.length === 0) {
+    return "No workspace folders found.";
+  }
+  return targets.map(formatCurrentTarget).join("\n\n");
+}
+function formatCurrentTarget(target) {
+  const heading = target.name ? `${target.name} (${target.path})` : target.path;
+  if (!target.current) {
+    if (target.mismatch) {
+      return [
+        `Current change in ${heading}: mismatch`,
+        `Session: ${target.mismatch.session.id}`,
+        `Branch: ${target.mismatch.branch.id}`,
+        `Resolve with: weave change switch ${target.mismatch.branch.id}`
+      ].join("\n");
+    }
+    return `Current change in ${heading}: none`;
+  }
+  return [
+    `Current change in ${heading}: ${target.current.id}`,
+    `Title: ${target.current.title}`,
+    `Type: ${target.current.type}`,
+    `Stage: ${target.current.stage}`,
+    ...formatStaleLines(target.current.stale),
+    ...formatKnowledgeLines(target.current.knowledge),
+    `Branch: ${target.current.branch}`,
+    `Path: ${target.current.path}`,
+    `Source: ${formatCurrentSource(target.source)}`
+  ].join("\n");
+}
+function formatStatusMessage(targets) {
+  if (targets.length === 0) {
+    return "No workspace folders found.";
+  }
+  return targets.map(formatStatusTarget).join("\n\n");
+}
+function formatStatusTarget(target) {
+  const heading = target.name ? `${target.name} (${target.path})` : target.path;
+  if (target.mismatch) {
+    return [
+      `Status in ${heading}: mismatch`,
+      `Session: ${target.mismatch.session.id}`,
+      `Branch: ${target.mismatch.branch.id}`,
+      `Resolve with: weave change switch ${target.mismatch.branch.id}`
+    ].join("\n");
+  }
+  if (!target.change) {
+    return `Status in ${heading}: no active change`;
+  }
+  return [
+    `Status in ${heading}: ${target.change.id}`,
+    `Title: ${target.change.title}`,
+    `Type: ${target.change.type}`,
+    `Stage: ${target.change.stage}`,
+    ...formatStaleLines(target.change.stale),
+    ...formatKnowledgeLines(target.change.knowledge),
+    `Branch: ${target.change.branch}`,
+    `Path: ${target.change.path}`,
+    `Active: ${target.active ? "yes" : "no"}`,
+    `Branch match: ${target.branchMatch}`,
+    `Source: ${formatCurrentSource(target.source)}`
+  ].join("\n");
+}
+function formatProgressMessage(target, change, progressed, note) {
+  const heading = target.name ? `${target.name} (${target.path})` : target.path;
+  return [
+    `Progressed change in ${heading}: ${change.id}`,
+    `Progressed lane: ${progressed}`,
+    `Stage: ${change.stage}`,
+    ...formatStaleLines(change.stale),
+    ...formatKnowledgeLines(change.knowledge),
+    ...note ? [`Note: ${note}`] : [],
+    `Path: ${change.path}`
+  ].join("\n");
+}
+function formatKnowledgeMessage(target, change) {
+  const heading = target.name ? `${target.name} (${target.path})` : target.path;
+  return [
+    `Updated knowledge status in ${heading}: ${change.id}`,
+    ...formatKnowledgeLines(change.knowledge),
+    `Stage: ${change.stage}`,
+    `Path: ${change.path}`
+  ].join("\n");
+}
+function formatStaleLines(stale) {
+  const entries = changeStages.filter((stage) => stale[stage]).map((stage) => {
+    const metadata = stale[stage];
+    return `${stage} (invalidated by ${metadata.invalidated_by})`;
+  });
+  return entries.length > 0 ? [`Stale: ${entries.join(", ")}`] : [];
+}
+function formatKnowledgeLines(knowledge) {
+  if (!knowledge) {
+    return [];
+  }
+  const suffix = knowledge.status === "stale" && knowledge.invalidated_by ? ` (invalidated by ${knowledge.invalidated_by})` : "";
+  return [`Knowledge: ${knowledge.status}${suffix}`];
+}
+function formatCurrentSource(source) {
+  switch (source) {
+    case "inferred_saved":
+      return "inferred from branch and saved";
+    case "session":
+      return "session";
+    case "explicit":
+      return "explicit";
+    case "none":
+      return "none";
+  }
+}
+function formatBranchStatus(status) {
+  switch (status) {
+    case "already_active":
+      return "branch already active";
+    case "checked_out":
+      return "branch checked out";
+    case "created":
+      return "branch created";
+    case "skipped_not_git":
+      return "branch skipped: not a git repo";
+  }
+}
+function isChangeType(value) {
+  return typeof value === "string" && changeTypes.includes(value);
+}
+function isChangeStage(value) {
+  return typeof value === "string" && changeStages.includes(value);
+}
+function isStoredChangeStage(value) {
+  return typeof value === "string" && storedStages.includes(value);
+}
+function isArtifactSourceId(value) {
+  return typeof value === "string" && artifactSourceIds.includes(value);
+}
+function isKnowledgeStatus(value) {
+  return typeof value === "string" && knowledgeStatuses.includes(value);
+}
+function isKnowledgeInvalidationSource(value) {
+  return isChangeStage(value) || isArtifactSourceId(value);
+}
+function normalizeKnowledgeInvalidationSource(value) {
+  if (isKnowledgeInvalidationSource(value)) {
+    return value;
+  }
+  const supported = dedupeStrings([...changeStages, ...artifactSourceIds]);
+  throw new ChangeCommandError(
+    "unsupported_knowledge_invalidation_source",
+    `Unsupported knowledge invalidation source: ${value}. Expected ${supported.join(", ")}`,
+    { source: value, supported }
+  );
+}
+function maxStage(stages) {
+  const highest = stages.reduce(
+    (acc, stage) => stageIndex(stage) > stageIndex(acc) ? stage : acc,
+    "exploration"
+  );
+  return isChangeStage(highest) ? highest : "exploration";
+}
+function stageIndex(stage) {
+  return changeStages.indexOf(stage);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/lib/artifact-context.ts
+async function currentArtifact(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const changeResult = await currentChange({ cwd: options.cwd, now, sessionPath });
+  const session = await loadCurrentSession(sessionPath);
+  const targets = changeResult.targets.map((target) => {
+    const saved = currentArtifactForPath(session, target.path);
+    const valid = Boolean(saved && target.current && saved.change_id === target.current.id);
+    return {
+      id: target.id,
+      name: target.name,
+      path: target.path,
+      source: valid ? "session" : "none",
+      current: valid,
+      artifact: valid ? saved : void 0,
+      current_change: target.current ? { id: target.current.id, path: target.current.path, branch: target.current.branch } : void 0
+    };
+  });
+  return {
+    status: "ok",
+    targets,
+    message: formatCurrentArtifactMessage(targets)
+  };
+}
+async function setCurrentArtifact(options) {
+  const artifact = parseArtifact(options.artifact);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const changeResult = await currentChange({ cwd: options.cwd, now, sessionPath });
+  if (changeResult.targets.length !== 1) {
+    throw new ChangeCommandError("ambiguous_target", "Set current artifact for one target at a time");
+  }
+  const target = changeResult.targets[0];
+  if (!target.current) {
+    throw new ChangeCommandError("no_current_change", "No active Weave change found. Run `weave change new` or `weave change switch` first.");
+  }
+  const session = await loadCurrentSession(sessionPath) ?? {
+    version: 1,
+    updated_at: now.toISOString(),
+    folders: {}
+  };
+  const artifactState = {
+    artifact,
+    change_id: target.current.id,
+    path: await resolveArtifactContextPath(target.current.path, target.current.changePath, artifact)
+  };
+  setCurrentArtifactForPath(session, target.path, artifactState, now);
+  await saveCurrentSession(session, sessionPath);
+  const saved = currentArtifactForPath(session, target.path);
+  const results = [
+    {
+      id: target.id,
+      name: target.name,
+      path: target.path,
+      source: "session",
+      current: true,
+      artifact: saved,
+      current_change: {
+        id: target.current.id,
+        path: target.current.path,
+        branch: target.current.branch
+      }
+    }
+  ];
+  return {
+    status: "ok",
+    targets: results,
+    message: formatCurrentArtifactMessage(results)
+  };
+}
+async function clearCurrentArtifact(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const changeResult = await currentChange({ cwd: options.cwd, now, sessionPath });
+  if (changeResult.targets.length !== 1) {
+    throw new ChangeCommandError("ambiguous_target", "Clear current artifact for one target at a time");
+  }
+  const target = changeResult.targets[0];
+  const session = await loadCurrentSession(sessionPath) ?? {
+    version: 1,
+    updated_at: now.toISOString(),
+    folders: {}
+  };
+  clearCurrentArtifactForPath(session, target.path, now);
+  await saveCurrentSession(session, sessionPath);
+  const results = [
+    {
+      id: target.id,
+      name: target.name,
+      path: target.path,
+      source: "none",
+      current: false,
+      current_change: target.current ? { id: target.current.id, path: target.current.path, branch: target.current.branch } : void 0
+    }
+  ];
+  return {
+    status: "ok",
+    targets: results,
+    message: formatCurrentArtifactMessage(results)
+  };
+}
+function parseArtifact(value) {
+  if (isArtifactName(value)) {
+    return value;
+  }
+  throw new ChangeCommandError("invalid_artifact", `Unsupported artifact: ${value}. Expected exploration, prd, or architecture.`);
+}
+async function resolveArtifactContextPath(changeRelativePath, changeAbsolutePath, artifact) {
+  if (artifact !== "architecture") {
+    return path9.join(changeRelativePath, artifactFileName(artifact));
+  }
+  const architecture = await resolveArchitectureArtifact(changeAbsolutePath);
+  if ((architecture.status === "folder" || architecture.status === "conflict") && architecture.indexExists) {
+    return path9.join(changeRelativePath, "architecture", "index.md");
+  }
+  return path9.join(changeRelativePath, "architecture.md");
+}
+function formatCurrentArtifactMessage(targets) {
+  return targets.map((target) => {
+    const label = target.name ? `${target.name} (${target.path})` : target.path;
+    if (!target.artifact) {
+      return [`Target: ${label}`, "Current artifact: none"].join("\n");
+    }
+    return [
+      `Target: ${label}`,
+      `Current artifact: ${target.artifact.artifact}`,
+      `Change: ${target.artifact.change_id}`,
+      `Path: ${target.artifact.path}`
+    ].join("\n");
+  }).join("\n\n");
+}
+
+// src/commands/artifact.ts
+function artifactCommand() {
+  const command = new Command3("artifact").description("Inspect and route Weave artifact context.");
+  const current = new Command3("current").description("Show, set, or clear the current artifact context.").option("--json", "print machine-readable JSON").action(async (options) => {
+    await runAction2(options.json ?? false, async () => {
+      const result3 = await currentArtifact({
+        cwd: process.cwd()
+      });
+      writeResult(result3, options.json ?? false);
+    });
+  });
+  current.command("set").description("Set the current artifact context for the active change.").argument("<artifact>", "artifact: exploration, prd, or architecture", parseArtifactName).option("--json", "print machine-readable JSON").action(async (artifact, options) => {
+    await runAction2(options.json ?? false, async () => {
+      const result3 = await setCurrentArtifact({
+        cwd: process.cwd(),
+        artifact
+      });
+      writeResult(result3, options.json ?? false);
+    });
+  });
+  current.command("clear").description("Clear the current artifact context for the active change.").option("--json", "print machine-readable JSON").action(async (options) => {
+    await runAction2(options.json ?? false, async () => {
+      const result3 = await clearCurrentArtifact({
+        cwd: process.cwd()
+      });
+      writeResult(result3, options.json ?? false);
+    });
+  });
+  command.addCommand(current);
+  return command;
+}
+function parseArtifactName(value) {
+  if (isArtifactName(value)) {
+    return value;
+  }
+  throw new InvalidArgumentError2(`Unsupported artifact: ${value}`);
+}
+function writeResult(result3, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result3, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${result3.message}
+`);
+}
+async function runAction2(json, action) {
+  try {
+    await action();
+  } catch (error) {
+    if (json) {
+      process.stdout.write(`${JSON.stringify(errorResult(error), null, 2)}
+`);
+    } else {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+function errorResult(error) {
+  if (error instanceof ChangeCommandError) {
+    return {
+      status: "error",
+      code: error.code,
+      message: error.message,
+      details: error.details
+    };
+  }
+  return {
+    status: "error",
+    code: "unknown_error",
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+
+// src/commands/change.ts
+import { Command as Command4, InvalidArgumentError as InvalidArgumentError3 } from "commander";
+
+// src/lib/with-notices.ts
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFile as readFile9 } from "fs/promises";
+
+// src/lib/notices.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join2 } from "path";
+async function gatherNotices(options) {
+  const env = options.env ?? process.env;
+  if (env.WEAVE_NO_NOTICES === "1") {
+    return [];
+  }
+  const notices = [];
+  if (options.npmLatest && isNewerVersion(options.npmLatest, options.packageVersion)) {
+    notices.push({
+      kind: "package_outdated",
+      message: `weave-it ${options.npmLatest} is available (installed ${options.packageVersion}). Run 'weave status' for details.`,
+      details: {
+        installed: options.packageVersion,
+        latest: options.npmLatest
+      }
+    });
+  }
+  const drift = await detectSkillDrift({
+    cwd: options.cwd,
+    templatesDir: options.templatesDir
+  });
+  if (drift.modified.length > 0) {
+    notices.push({
+      kind: "skills_modified",
+      message: `${drift.modified.length} installed skill file(s) have been modified locally. Run 'weave status' for details.`,
+      details: { skills: drift.modified }
+    });
+  }
+  if (drift.outdated.length > 0) {
+    notices.push({
+      kind: "skills_outdated",
+      message: `${drift.outdated.length} installed skill file(s) are out of date. Run 'weave agent update --all' or 'weave status' for details.`,
+      details: { skills: drift.outdated }
+    });
+  }
+  return notices;
+}
+async function detectSkillDrift(options) {
+  const manifest = await loadAgentsManifest(options.cwd);
+  const templates = await safeListDefaultSkills(options.templatesDir);
+  const templatesByName = new Map(templates.map((skill) => [skill.name, skill]));
+  const modified = [];
+  const outdated = [];
+  for (const [agentKey, buckets] of Object.entries(manifest.installed)) {
+    if (!buckets) continue;
+    const skillEntries = buckets.skills ?? {};
+    for (const [name, entry] of Object.entries(skillEntries)) {
+      const absolutePath = join2(options.cwd, entry.path);
+      const diskHash = await safeHashFile(absolutePath);
+      if (diskHash === null) {
+        continue;
+      }
+      if (diskHash !== entry.installed_hash) {
+        modified.push({ agent: agentKey, name, kind: "skill" });
+        continue;
+      }
+      const template = templatesByName.get(name);
+      if (!template) continue;
+      if (entry.installed_from !== template.lastChangedIn) {
+        outdated.push({
+          agent: agentKey,
+          name,
+          kind: "skill",
+          installed_from: entry.installed_from,
+          current: template.lastChangedIn
+        });
+      }
+    }
+  }
+  modified.sort(compareSkillRefs);
+  outdated.sort(compareSkillRefs);
+  return { modified, outdated };
+}
+async function safeListDefaultSkills(templatesDir) {
+  try {
+    return await listDefaultSkills({ templatesDir });
+  } catch {
+    return [];
+  }
+}
+async function safeHashFile(path14) {
+  try {
+    const content = await readFile8(path14, "utf8");
+    return `sha256:${createHash3("sha256").update(content).digest("hex")}`;
+  } catch {
+    return null;
+  }
+}
+function compareSkillRefs(left, right) {
+  const agentCompare = left.agent.localeCompare(right.agent);
+  if (agentCompare !== 0) return agentCompare;
+  return left.name.localeCompare(right.name);
+}
+function isNewerVersion(candidate, baseline) {
+  const parsedCandidate = parseSemver(candidate);
+  const parsedBaseline = parseSemver(baseline);
+  if (!parsedCandidate || !parsedBaseline) {
+    return false;
+  }
+  for (let index = 0; index < 3; index++) {
+    if (parsedCandidate[index] > parsedBaseline[index]) return true;
+    if (parsedCandidate[index] < parsedBaseline[index]) return false;
+  }
+  return false;
+}
+function parseSemver(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(value);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+// src/lib/user-paths.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+function getUserHome(env = process.env) {
+  return env.WEAVE_USER_HOME || homedir();
+}
+function getUserWeaveDir(env = process.env) {
+  return join3(getUserHome(env), ".weave");
+}
+function getUserCacheDir(env = process.env) {
+  return join3(getUserWeaveDir(env), "cache");
+}
+function getNpmVersionCachePath(env = process.env) {
+  return join3(getUserCacheDir(env), "npm-version.json");
+}
+
+// src/lib/npm-version.ts
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/weave-it/latest";
+var FETCH_TIMEOUT_MS = 3e3;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+async function getNpmVersionInfo(options) {
+  const env = options.env ?? process.env;
+  if (env.NO_UPDATE_NOTIFIER === "1" || env.WEAVE_NO_NOTICES === "1") {
+    return { cachedLatest: null, isStale: true, fetchedAt: null };
+  }
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const cachePath = options.cachePath ?? getNpmVersionCachePath(env);
+  const cache = await readJsonCache(cachePath);
+  let cachedLatest = null;
+  let fetchedAt = null;
+  let isStale = true;
+  if (cache && typeof cache.latest === "string" && typeof cache.fetched_at === "string") {
+    const parsed = Date.parse(cache.fetched_at);
+    if (!Number.isNaN(parsed)) {
+      cachedLatest = cache.latest;
+      fetchedAt = new Date(parsed);
+      isStale = now.getTime() - parsed > CACHE_TTL_MS;
+    }
+  }
+  if (isStale) {
+    void refreshNpmVersionCache({
+      cachePath,
+      now,
+      fetchImpl: options.fetchImpl ?? fetch,
+      packageVersion: options.packageVersion
+    });
+  }
+  return { cachedLatest, isStale, fetchedAt };
+}
+async function refreshNpmVersionCache(opts) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await opts.fetchImpl(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { "user-agent": `weave-it/${opts.packageVersion}` }
+    });
+    if (!response.ok) return;
+    const parsed = await response.json();
+    if (typeof parsed?.version !== "string") return;
+    await writeJsonCache(opts.cachePath, {
+      latest: parsed.version,
+      fetched_at: opts.now.toISOString()
+    });
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/lib/with-notices.ts
+async function withNotices(options, action) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const packageVersion = options.packageVersion ?? await readPackageVersion();
+  const noticesPromise = gatherNoticesSafely({ cwd, packageVersion, env });
+  const actionResult = await action();
+  const notices = await noticesPromise;
+  if (options.json) {
+    const payload = mergeNoticesIntoJson(actionResult.json, notices);
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${actionResult.text}
+`);
+    if (shouldShowFooter(notices, env)) {
+      process.stderr.write(renderFooter(notices));
+    }
+  }
+  if (actionResult.exitCode !== void 0 && actionResult.exitCode !== 0) {
+    process.exitCode = actionResult.exitCode;
+  }
+}
+async function gatherNoticesSafely(opts) {
+  try {
+    const npmInfo = await getNpmVersionInfo({
+      packageVersion: opts.packageVersion,
+      env: opts.env
+    });
+    return await gatherNotices({
+      cwd: opts.cwd,
+      packageVersion: opts.packageVersion,
+      npmLatest: npmInfo.cachedLatest,
+      env: opts.env
+    });
+  } catch {
+    return [];
+  }
+}
+function mergeNoticesIntoJson(json, notices) {
+  if (json && typeof json === "object" && !Array.isArray(json)) {
+    return { ...json, notices };
+  }
+  return { result: json, notices };
+}
+function shouldShowFooter(notices, env) {
+  if (notices.length === 0) return false;
+  if (env.WEAVE_NO_NOTICES === "1") return false;
+  if (env.CI && env.CI !== "" && env.CI !== "false" && env.CI !== "0") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+function renderFooter(notices) {
+  return `weave-it: ${notices.length} notice(s) - run 'weave status' for details
+`;
+}
+async function readPackageVersion() {
+  let current = dirname3(fileURLToPath2(import.meta.url));
+  while (true) {
+    const candidate = join4(current, "package.json");
+    if (await pathExists(candidate)) {
+      try {
+        const parsed = JSON.parse(await readFile9(candidate, "utf8"));
+        if (typeof parsed?.version === "string") return parsed.version;
+      } catch {
+      }
+    }
+    const parent = dirname3(current);
+    if (parent === current) return "0.0.0";
+    current = parent;
+  }
+}
+
+// src/commands/change.ts
+function changeCommand() {
+  const command = new Command4("change").description("Create and inspect Weave change artifacts.");
+  command.command("new").description("Create a change exploration.").argument("<title>", "change title").option("--type <type>", "change type: feat, fix, refactor, docs, test, ci, or chore", parseChangeType, "feat").option("--slug <slug>", "change slug override").option("--json", "print machine-readable JSON").action(async (title, options) => {
+    const json = options.json ?? false;
+    await runAction3(json, async () => {
+      await withNotices({ commandName: "change-new", json }, async () => {
+        const result3 = await createChange({
+          cwd: process.cwd(),
+          title,
+          type: options.type,
+          slug: options.slug
+        });
+        return { json: result3, text: result3.message };
+      });
+    });
+  });
+  command.command("list").description("List changes.").option("--json", "print machine-readable JSON").action(async (options) => {
+    await runAction3(options.json ?? false, async () => {
+      const result3 = await listChanges({
+        cwd: process.cwd()
+      });
+      writeResult2(result3, options.json ?? false);
+    });
+  });
+  command.command("current").description("Show the current active change.").option("--json", "print machine-readable JSON").action(async (options) => {
+    const json = options.json ?? false;
+    await runAction3(json, async () => {
+      await withNotices({ commandName: "change-current", json }, async () => {
+        const result3 = await currentChange({ cwd: process.cwd() });
+        return { json: result3, text: result3.message };
+      });
+    });
+  });
+  command.command("status").description("Show active change status and branch alignment.").argument("[change]", "change reference to inspect without switching").option("--json", "print machine-readable JSON").action(async (change, options) => {
+    const json = options.json ?? false;
+    await runAction3(json, async () => {
+      await withNotices({ commandName: "change-status", json }, async () => {
+        const result3 = await statusChange({
+          cwd: process.cwd(),
+          change
+        });
+        return { json: result3, text: result3.message };
+      });
+    });
+  });
+  command.command("progress").description("Record lifecycle progress for the active change.").argument("<lane>", "lane: exploration, prd, architecture, or issues", parseChangeStage).option("--source <source>", "source dependency: exploration, prd, architecture, discussion, sessions, or codebase", collectValues, []).option("--no-invalidate", "suppress all downstream stale propagation").option(
+    "--invalidate <lanes>",
+    "mark only this comma-separated subset of dependent lanes stale (e.g. issues,prd)"
+  ).option("--json", "print machine-readable JSON").action(async (stage, options) => {
+    await runAction3(options.json ?? false, async () => {
+      const invalidate = options.invalidate;
+      const result3 = await progressChange({
+        cwd: process.cwd(),
+        stage,
+        sources: options.source,
+        noInvalidate: invalidate === false,
+        invalidateOnly: typeof invalidate === "string" ? parseInvalidateList(invalidate) : void 0
+      });
+      writeResult2(result3, options.json ?? false);
+    });
+  });
+  command.command("clear-stale").description("Explicitly clear a stale lane flag after content-sync verification.").argument("<lane>", "lane: exploration, prd, architecture, or issues", parseChangeStage).option("--reason <reason>", "one-sentence verification rationale recorded in stale_history").option("--json", "print machine-readable JSON").action(async (lane, options) => {
+    await runAction3(options.json ?? false, async () => {
+      const result3 = await clearChangeStaleness({
+        cwd: process.cwd(),
+        lane,
+        reason: options.reason
+      });
+      writeResult2(result3, options.json ?? false);
+    });
+  });
+  command.command("knowledge").description("Record knowledge freshness for the active change.").argument("<status>", "knowledge status: pending, stale, updated, or none", parseKnowledgeStatus).option("--domain <domain>", "affected knowledge domain", collectValues).option("--shared <shared>", "affected shared behavior area", collectValues).option("--file <file>", "touched or authoritative knowledge file", collectValues).option("--delta <delta>", "change-local knowledge delta file").option("--reason <reason>", "reason for the knowledge status").option("--invalidated-by <source>", "source that invalidated knowledge freshness").option("--json", "print machine-readable JSON").action(async (status, options) => {
+    await runAction3(options.json ?? false, async () => {
+      const result3 = await knowledgeChange({
+        cwd: process.cwd(),
+        status,
+        domains: options.domain,
+        shared: options.shared,
+        files: options.file,
+        delta: options.delta,
+        reason: options.reason,
+        invalidatedBy: options.invalidatedBy
+      });
+      writeResult2(result3, options.json ?? false);
+    });
+  });
+  command.command("switch").description("Switch to an existing change.").argument("<change>", "change id, token, slug, or title substring").option("--json", "print machine-readable JSON").action(async (change, options) => {
+    await runAction3(options.json ?? false, async () => {
+      const result3 = await switchChange({
+        cwd: process.cwd(),
+        change
+      });
+      writeResult2(result3, options.json ?? false);
+    });
+  });
+  return command;
+}
+function parseKnowledgeStatus(value) {
+  if (isKnowledgeStatus(value)) {
+    return value;
+  }
+  throw new InvalidArgumentError3(`Unsupported knowledge status: ${value}. Expected ${knowledgeStatuses.join(", ")}`);
+}
+function parseChangeStage(value) {
+  if (isChangeStage(value)) {
+    return value;
+  }
+  throw new InvalidArgumentError3(`Unsupported change stage: ${value}. Expected ${changeStages.join(", ")}`);
+}
+function parseInvalidateList(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return [];
+  const parts = trimmed.split(",").map((part) => part.trim()).filter(Boolean);
+  for (const part of parts) {
+    if (!isChangeStage(part)) {
+      throw new InvalidArgumentError3(
+        `Unsupported lane in --invalidate: ${part}. Expected ${changeStages.join(", ")}`
+      );
+    }
+  }
+  return parts;
+}
+function parseChangeType(value) {
+  if (changeTypes.includes(value)) {
+    return value;
+  }
+  throw new InvalidArgumentError3(`Unsupported change type: ${value}`);
+}
+function collectValues(value, previous = []) {
+  return [...previous, value];
+}
+function writeResult2(result3, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result3, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${result3.message}
+`);
+}
+async function runAction3(json, action) {
+  try {
+    await action();
+  } catch (error) {
+    if (json) {
+      process.stdout.write(`${JSON.stringify(errorResult2(error), null, 2)}
+`);
+    } else {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+function errorResult2(error) {
+  if (error instanceof ChangeCommandError) {
+    return {
+      status: "error",
+      code: error.code,
+      message: error.message,
+      details: error.details
+    };
+  }
+  return {
+    status: "error",
+    code: "unknown_error",
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+
+// src/commands/init.ts
+import { Command as Command5 } from "commander";
+
+// src/lib/init-workspace.ts
+import * as prompts from "@clack/prompts";
+import { readFile as readFile10, realpath as realpath5 } from "fs/promises";
+import path10 from "path";
+import YAML8 from "yaml";
+async function initWorkspace(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const existingSession = await loadCurrentSession(sessionPath);
+  if (existingSession && !await shouldReplaceSession(options)) {
+    return {
+      status: "cancelled",
+      message: "Cancelled. Existing Weave session was not replaced.",
+      folderPath: cwd,
+      wikiDir: "",
+      metadataDir: "",
+      sessionPath
+    };
+  }
+  const mode = await selectInitMode(options);
+  if (mode === "cancelled") {
+    return {
+      status: "cancelled",
+      message: "Cancelled. Weave was not initialized.",
+      folderPath: cwd,
+      wikiDir: "",
+      metadataDir: "",
+      sessionPath
+    };
+  }
+  if (mode === "workspace") {
+    return initWorkspaceMode({ ...options, cwd, now, sessionPath });
+  }
+  return initRepoMode({ ...options, cwd, now, sessionPath });
+}
+async function initRepoMode(options) {
+  const folder = await resolveFolder({
+    cwd: options.cwd,
+    id: options.folderId,
+    kind: options.folderKind
+  });
+  const scaffold = await ensureWeaveScaffold({ folder });
+  const workspaceMetadata = await writeRepoWorkspaceMetadata(folder);
+  if (workspaceMetadata) {
+    scaffold.created.push(".weave/workspace.yml");
+  }
+  const session = createCurrentSession(folder, options.now);
+  await saveCurrentSession(session, options.sessionPath);
+  return {
+    status: "initialized",
+    mode: "repo",
+    message: initializedMessage({
+      mode: "repo",
+      folderId: folder.id,
+      folderPath: folder.path,
+      created: scaffold.created,
+      sessionPath: options.sessionPath
+    }),
+    folderPath: folder.path,
+    wikiDir: scaffold.wikiDir,
+    metadataDir: scaffold.metadataDir,
+    sessionPath: options.sessionPath
+  };
+}
+async function initWorkspaceMode(options) {
+  const gitRoot = await findGitRoot(options.cwd);
+  if (gitRoot) {
+    return initWorkspaceFromGitRepo(options, await realpath5(gitRoot));
+  }
+  return initWorkspaceWithoutGitRepo(options);
+}
+async function initWorkspaceFromGitRepo(options, gitRoot) {
+  const repoDirectoryName = path10.basename(gitRoot);
+  const defaultWorkspaceName = `${repoDirectoryName}-workspace`;
+  if ((options.yes || options.interactive === false) && !options.workspacePath && await isWeaveSourceRepo(gitRoot)) {
+    throw new Error(
+      "Refusing to adopt the Weave source repo without --workspace-path. Run this command from a disposable test repo, or pass an explicit workspace path."
+    );
+  }
+  const workspaceName = await resolveWorkspaceName(options, defaultWorkspaceName);
+  if (workspaceName === "cancelled") {
+    return cancelledWorkspace(options.cwd, options.sessionPath);
+  }
+  const workspacePath = options.workspacePath ? path10.resolve(options.cwd, options.workspacePath) : path10.join(path10.dirname(gitRoot), slugify(workspaceName, "workspace"));
+  const repoTargetPath = path10.join(workspacePath, repoDirectoryName);
+  await assertPathMissing(workspacePath, "Workspace path already exists");
+  await assertPathMissing(repoTargetPath, "Repo target path already exists");
+  const remote = await getGitRemote(gitRoot);
+  await createDirExclusive(workspacePath);
+  await movePath(gitRoot, repoTargetPath);
+  const resolvedWorkspacePath = await realpath5(workspacePath);
+  const created = await scaffoldWorkspace({
+    workspacePath: resolvedWorkspacePath,
+    workspaceName,
+    repos: {
+      [slugify(repoDirectoryName, "repo")]: {
+        path: repoDirectoryName,
+        kind: options.folderKind ?? "app",
+        ...remote ? { remote } : {}
+      }
+    }
+  });
+  const folder = workspaceFolder(resolvedWorkspacePath, workspaceName, options.folderId);
+  const commitCreated = await createInitialWorkspaceCommit(resolvedWorkspacePath);
+  const session = createCurrentSession(folder, options.now);
+  await saveCurrentSession(session, options.sessionPath);
+  return {
+    status: "initialized",
+    mode: "workspace",
+    message: initializedMessage({
+      mode: "workspace",
+      folderId: folder.id,
+      folderPath: folder.path,
+      created,
+      sessionPath: options.sessionPath,
+      oldRepoPath: gitRoot,
+      newRepoPath: repoTargetPath,
+      commitCreated
+    }),
+    folderPath: folder.path,
+    wikiDir: path10.join(resolvedWorkspacePath, "wiki"),
+    metadataDir: path10.join(resolvedWorkspacePath, ".weave"),
+    sessionPath: options.sessionPath,
+    commitCreated,
+    warning: commitCreated ? void 0 : "Initial workspace commit was not created. Run git status in the workspace to recover."
+  };
+}
+async function initWorkspaceWithoutGitRepo(options) {
+  const workspacePath = await resolveWorkspacePath(options);
+  if (workspacePath === "cancelled") {
+    return cancelledWorkspace(options.cwd, options.sessionPath);
+  }
+  const workspaceName = await resolveWorkspaceName(options, path10.basename(workspacePath));
+  if (workspaceName === "cancelled") {
+    return cancelledWorkspace(options.cwd, options.sessionPath);
+  }
+  const workspacePathExists = await pathExists(workspacePath);
+  if (workspacePathExists) {
+    const currentPath = await realpath5(options.cwd);
+    const targetPath = await realpath5(workspacePath);
+    const isCurrentPath = currentPath === targetPath;
+    if (!isCurrentPath || !await isDirectoryEmpty(workspacePath)) {
+      throw new Error(`Workspace path already exists and is not an empty current directory: ${workspacePath}`);
+    }
+  } else {
+    await createDirExclusive(workspacePath);
+  }
+  const created = await scaffoldWorkspace({
+    workspacePath,
+    workspaceName,
+    repos: {}
+  });
+  const folder = workspaceFolder(await realpath5(workspacePath), workspaceName, options.folderId);
+  const commitCreated = await createInitialWorkspaceCommit(folder.path);
+  const session = createCurrentSession(folder, options.now);
+  await saveCurrentSession(session, options.sessionPath);
+  return {
+    status: "initialized",
+    mode: "workspace",
+    message: initializedMessage({
+      mode: "workspace",
+      folderId: folder.id,
+      folderPath: folder.path,
+      created,
+      sessionPath: options.sessionPath,
+      commitCreated
+    }),
+    folderPath: folder.path,
+    wikiDir: path10.join(folder.path, "wiki"),
+    metadataDir: path10.join(folder.path, ".weave"),
+    sessionPath: options.sessionPath,
+    commitCreated,
+    warning: commitCreated ? void 0 : "Initial workspace commit was not created. Run git status in the workspace to recover."
+  };
+}
+async function selectInitMode(options) {
+  if (options.mode) {
+    if (options.mode === "repo" || options.mode === "workspace") {
+      return options.mode;
+    }
+    throw new Error(`Unsupported init mode: ${options.mode}. Expected "repo" or "workspace".`);
+  }
+  if (options.yes || options.interactive === false) {
+    return "repo";
+  }
+  const answer = await prompts.select({
+    message: "How should Weave initialize this folder?",
+    options: [
+      {
+        value: "repo",
+        label: "Repo mode",
+        hint: "Use this when you want to code/reference only this repo."
+      },
+      {
+        value: "workspace",
+        label: "Workspace mode",
+        hint: "Use this when you work across multiple repos or folders."
+      }
+    ],
+    initialValue: "repo"
+  });
+  if (prompts.isCancel(answer)) {
+    prompts.cancel("Cancelled.");
+    return "cancelled";
+  }
+  return answer;
+}
+async function shouldReplaceSession(options) {
+  if (options.yes || options.interactive === false) {
+    return true;
+  }
+  const answer = await prompts.confirm({
+    message: "A Weave session already exists. Start a new session from this folder?",
+    initialValue: true
+  });
+  if (prompts.isCancel(answer)) {
+    prompts.cancel("Cancelled.");
+    return false;
+  }
+  return answer;
+}
+async function resolveWorkspaceName(options, defaultName) {
+  if (options.workspaceName) {
+    return options.workspaceName;
+  }
+  if (options.yes || options.interactive === false) {
+    return defaultName;
+  }
+  const answer = await prompts.text({
+    message: "Workspace name",
+    placeholder: defaultName,
+    defaultValue: defaultName
+  });
+  if (prompts.isCancel(answer)) {
+    prompts.cancel("Cancelled.");
+    return "cancelled";
+  }
+  return String(answer).trim() || defaultName;
+}
+async function resolveWorkspacePath(options) {
+  if (options.workspacePath) {
+    return path10.resolve(options.cwd, options.workspacePath);
+  }
+  if (options.yes || options.interactive === false) {
+    throw new Error("Workspace path is required for workspace mode outside a git repo.");
+  }
+  const answer = await prompts.text({
+    message: "Workspace path",
+    placeholder: path10.join(path10.dirname(options.cwd), "my-workspace")
+  });
+  if (prompts.isCancel(answer)) {
+    prompts.cancel("Cancelled.");
+    return "cancelled";
+  }
+  const value = String(answer).trim();
+  if (!value) {
+    throw new Error("Workspace path is required for workspace mode outside a git repo.");
+  }
+  return path10.resolve(options.cwd, value);
+}
+async function writeRepoWorkspaceMetadata(folder) {
+  return writeFileIfMissing(
+    path10.join(folder.path, ".weave", "workspace.yml"),
+    workspaceMetadataTemplate({
+      mode: "repo",
+      name: folder.name,
+      repos: {}
+    })
+  );
+}
+async function scaffoldWorkspace(input) {
+  await runGitRequired(["init"], input.workspacePath);
+  const folder = workspaceFolder(input.workspacePath, input.workspaceName);
+  const scaffold = await ensureWeaveScaffold({ folder });
+  const created = [...scaffold.created];
+  if (await writeFileIfMissing(
+    path10.join(input.workspacePath, ".weave", "workspace.yml"),
+    workspaceMetadataTemplate({
+      mode: "workspace",
+      name: input.workspaceName,
+      repos: {}
+    })
+  )) {
+    created.push(".weave/workspace.yml");
+  }
+  if (await writeFileIfMissing(
+    path10.join(input.workspacePath, ".gitignore"),
+    workspaceGitignoreBaseTemplate()
+  )) {
+    created.push(".gitignore");
+  }
+  for (const [id, repo] of Object.entries(input.repos)) {
+    await registerRepoIntoWorkspace({
+      workspacePath: input.workspacePath,
+      id,
+      relativePath: repo.path,
+      kind: repo.kind,
+      remote: repo.remote
+    });
+  }
+  return created;
+}
+async function createInitialWorkspaceCommit(workspacePath) {
+  try {
+    await runGitRequired(["add", "."], workspacePath);
+    await runGitRequired(["commit", "-m", "Initialize Weave workspace"], workspacePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function workspaceFolder(workspacePath, workspaceName, folderId) {
+  const id = folderId ?? slugify(workspaceName, "workspace");
+  return {
+    id,
+    path: workspacePath,
+    name: titleFromSlug(id) || workspaceName,
+    kind: "workspace"
+  };
+}
+async function assertPathMissing(targetPath, message) {
+  if (await pathExists(targetPath)) {
+    throw new Error(`${message}: ${targetPath}`);
+  }
+}
+async function isWeaveSourceRepo(gitRoot) {
+  try {
+    const manifest = JSON.parse(await readFile10(path10.join(gitRoot, "package.json"), "utf8"));
+    return manifest.name === "weave-it";
+  } catch {
+    return false;
+  }
+}
+function workspaceMetadataTemplate(input) {
+  return YAML8.stringify({
+    version: 1,
+    mode: input.mode,
+    name: input.name,
+    repos: input.repos
+  });
+}
+function cancelledWorkspace(folderPath, sessionPath) {
+  return {
+    status: "cancelled",
+    message: "Cancelled. Weave workspace was not initialized.",
+    folderPath,
+    wikiDir: "",
+    metadataDir: "",
+    sessionPath
+  };
+}
+function initializedMessage(input) {
+  const createdText = input.created.length > 0 ? input.created.join("\n  ") : "No repo files changed";
+  const modeText = input.mode === "workspace" ? "workspace mode" : "repo mode";
+  const repoMoveText = input.oldRepoPath && input.newRepoPath ? `
+Adopted repo:
+  From: ${input.oldRepoPath}
+  To:   ${input.newRepoPath}
+` : "";
+  const commitText = input.mode === "workspace" ? `
+Initial workspace commit:
+  ${input.commitCreated ? "Created" : "Not created - run git status in the workspace to recover"}
+` : "";
+  const nextText = input.mode === "workspace" ? `Open this workspace path in your editor:
+  ${input.folderPath}
+
+Then run:
+  weave workspace` : `weave add <path>
+  weave workspace`;
+  return `Initialized Weave in ${modeText} for folder: ${input.folderId}
+
+Folder:
+  ${input.folderPath}
+
+Created:
+  ${createdText}
+${repoMoveText}${commitText}
+
+Started current session:
+  ${input.folderId}
+
+Session state:
+  ${input.sessionPath}
+
+Next:
+  ${nextText}`;
+}
+
+// src/commands/init.ts
+function initCommand() {
+  return new Command5("init").description("Initialize Weave in repo mode or workspace mode and start a new session.").option("--id <id>", "folder id").option("--kind <kind>", "folder kind", "app").option("--mode <mode>", "init mode: repo or workspace; defaults to repo with --yes").option("--workspace-name <name>", "workspace name for workspace mode").option("--workspace-path <path>", "workspace path for workspace mode outside a git repo").option("--yes", "accept defaults and skip prompts").action(
+    async (options) => {
+      const result3 = await initWorkspace({
+        cwd: process.cwd(),
+        folderId: options.id,
+        folderKind: options.kind,
+        mode: options.mode,
+        workspaceName: options.workspaceName,
+        workspacePath: options.workspacePath,
+        yes: options.yes ?? false,
+        interactive: true
+      });
+      process.stdout.write(`${result3.message}
+`);
+      if (result3.status === "cancelled") {
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+
+// src/commands/skills.ts
+import { Command as Command6 } from "commander";
+function skillsCommand() {
+  const command = new Command6("skills").description("List Weave skills.");
+  command.command("list").description("List default skills shipped with Weave.").option("--json", "print machine-readable JSON").action(async (options) => {
+    await runAction4(async () => {
+      const skills = await listDefaultSkills();
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(skills, null, 2)}
+`);
+        return;
+      }
+      process.stdout.write(
+        `${skills.map((skill) => `${skill.name}	${skill.description}`).join("\n")}
+`
+      );
+    });
+  });
+  return command;
+}
+function skillCommand() {
+  const command = new Command6("skill").description("Show Weave skill content.");
+  command.command("show").description("Print a default skill shipped with Weave.").argument("<name>", "skill name").action(async (name) => {
+    await runAction4(async () => {
+      const skill = await readDefaultSkill(name);
+      process.stdout.write(skill.content);
+      if (!skill.content.endsWith("\n")) {
+        process.stdout.write("\n");
+      }
+    });
+  });
+  return command;
+}
+async function runAction4(action) {
+  try {
+    await action();
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/status.ts
+import { Command as Command7 } from "commander";
+
+// src/lib/status.ts
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile11 } from "fs/promises";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, join as join5 } from "path";
+var agentOrder = ["claude", "codex", "cursor", "opencode"];
+async function buildStatus(options) {
+  const packageVersion = options.packageVersion ?? await readPackageVersion2();
+  const inRepo = await pathExists(join5(options.cwd, ".weave", "agents.yml"));
+  const skills = inRepo ? await collectSkillRows(options) : [];
+  const npmLatest = options.npmLatest === void 0 ? (await getNpmVersionInfo({ packageVersion, env: options.env })).cachedLatest : options.npmLatest;
+  const notices = await gatherNotices({
+    cwd: options.cwd,
+    packageVersion,
+    npmLatest: npmLatest ?? null,
+    templatesDir: options.templatesDir,
+    env: options.env
+  });
+  return {
+    status: "ok",
+    packageVersion,
+    cwd: options.cwd,
+    inRepo,
+    skills,
+    notices,
+    message: renderStatusMessage({
+      packageVersion,
+      cwd: options.cwd,
+      inRepo,
+      skills,
+      notices,
+      npmLatest: npmLatest ?? null
+    })
+  };
+}
+async function collectSkillRows(options) {
+  const manifest = await loadAgentsManifest(options.cwd);
+  const templates = await listDefaultSkills({ templatesDir: options.templatesDir }).catch(() => []);
+  const templatesByName = new Map(templates.map((skill) => [skill.name, skill]));
+  const rows = [];
+  for (const agent of agentOrder) {
+    const buckets = manifest.installed[agent];
+    if (!buckets) continue;
+    const skills = buckets.skills ?? {};
+    for (const [name, entry] of Object.entries(skills)) {
+      const template = templatesByName.get(name);
+      const current = template?.lastChangedIn ?? "unknown";
+      const absolutePath = join5(options.cwd, entry.path);
+      const fileExists = await pathExists(absolutePath);
+      let state = "current";
+      if (!fileExists) {
+        state = "missing";
+      } else {
+        const diskContent = await readFile11(absolutePath, "utf8").catch(() => "");
+        const diskHash = `sha256:${createHash4("sha256").update(diskContent).digest("hex")}`;
+        if (diskHash !== entry.installed_hash) {
+          state = "modified";
+        } else if (template && entry.installed_from !== template.lastChangedIn) {
+          state = "outdated";
+        }
+      }
+      rows.push({
+        agent,
+        name,
+        installed_from: entry.installed_from,
+        current,
+        state
+      });
+    }
+  }
+  return rows;
+}
+function renderStatusMessage(opts) {
+  const lines = [];
+  lines.push(`weave-it ${opts.packageVersion}`);
+  lines.push(`cwd: ${opts.cwd}`);
+  if (opts.npmLatest) {
+    lines.push(`npm latest (cached): ${opts.npmLatest}`);
+  } else {
+    lines.push(`npm latest (cached): unknown`);
+  }
+  if (!opts.inRepo) {
+    lines.push("");
+    lines.push("Not inside a Weave-managed repo (no .weave/agents.yml).");
+  } else if (opts.skills.length === 0) {
+    lines.push("");
+    lines.push("No skills installed.");
+  } else {
+    lines.push("");
+    lines.push("Installed skills:");
+    const header = ["agent", "skill", "state", "installed_from", "current"];
+    const rows = opts.skills.map((row) => [
+      row.agent,
+      row.name,
+      row.state,
+      row.installed_from ?? "unknown",
+      row.current
+    ]);
+    const widths = header.map(
+      (cell, index) => Math.max(cell.length, ...rows.map((row) => row[index].length))
+    );
+    const renderRow = (cells) => cells.map((cell, index) => cell.padEnd(widths[index])).join("  ").trimEnd();
+    lines.push(renderRow(header));
+    lines.push(widths.map((width) => "-".repeat(width)).join("  ").trimEnd());
+    for (const row of rows) {
+      lines.push(renderRow(row));
+    }
+  }
+  lines.push("");
+  if (opts.notices.length === 0) {
+    lines.push("Notices: none.");
+  } else {
+    lines.push(`Notices (${opts.notices.length}):`);
+    for (const notice of opts.notices) {
+      lines.push(`- [${notice.kind}] ${notice.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function readPackageVersion2() {
+  const moduleDir = dirname4(fileURLToPath3(import.meta.url));
+  let current = moduleDir;
+  while (true) {
+    const candidate = join5(current, "package.json");
+    if (await pathExists(candidate)) {
+      try {
+        const parsed = JSON.parse(await readFile11(candidate, "utf8"));
+        if (typeof parsed?.version === "string") {
+          return parsed.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname4(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "0.0.0";
+}
+
+// src/commands/status.ts
+function statusCommand() {
+  return new Command7("status").description("Show installed weave-it package and skill version state.").option("--json", "print machine-readable JSON").action(async (options) => {
+    await withNotices(
+      { commandName: "status", json: options.json ?? false },
+      async () => {
+        const result3 = await buildStatus({ cwd: process.cwd() });
+        const { message: _message, notices: _notices, ...rest } = result3;
+        return {
+          json: rest,
+          text: result3.message
+        };
+      }
+    );
+  });
+}
+
+// src/commands/task.ts
+import { Command as Command8, InvalidArgumentError as InvalidArgumentError4 } from "commander";
+
+// src/lib/task-prepare.ts
+import { readFile as readFile13, writeFile as writeFile5 } from "fs/promises";
+import path12 from "path";
+import YAML9 from "yaml";
+
+// src/lib/tasks.ts
+import { readFile as readFile12 } from "fs/promises";
+import path11 from "path";
+async function loadTasksForChange(changePath) {
+  const tasksPath = path11.join(changePath, "tasks.md");
+  if (!await pathExists(tasksPath)) {
+    throw new ChangeCommandError("tasks_missing", "No tasks.md found for the active change. Run `weave-issues` first.", { path: tasksPath });
+  }
+  return parseTasksMarkdown(await readFile12(tasksPath, "utf8"));
+}
+function parseTasksMarkdown(content) {
+  const headings = [...content.matchAll(/^## (T\d+):\s*(.+)$/gm)];
+  const tasks = [];
+  for (let index = 0; index < headings.length; index += 1) {
+    const heading = headings[index];
+    const next = headings[index + 1];
+    const id = heading[1];
+    const title = heading[2].trim();
+    const start = heading.index ?? 0;
+    const end = next?.index ?? content.length;
+    const block = content.slice(start, end);
+    const fields = parseTaskFields(block);
+    tasks.push({
+      id,
+      title,
+      status: fields.get("status"),
+      type: fields.get("type"),
+      scope: fields.get("scope"),
+      primaryRepo: fields.get("primary repo"),
+      repos: parseRepoList(fields.get("repos"))
+    });
+  }
+  return tasks;
+}
+function selectTasks(tasks, selector) {
+  const availableTaskIds = tasks.map((task) => task.id);
+  const availableScopes = unique(tasks.map((task) => task.scope).filter((scope) => Boolean(scope)));
+  if (selector.type === "all") {
+    return { selector, tasks, availableTaskIds, availableScopes };
+  }
+  if (selector.type === "scope") {
+    const scope = selector.scope.toLowerCase();
+    return {
+      selector,
+      tasks: tasks.filter((task) => task.scope?.toLowerCase() === scope),
+      availableTaskIds,
+      availableScopes
+    };
+  }
+  const normalized = selector.ids.map((id) => id.toUpperCase());
+  const found = tasks.filter((task) => normalized.includes(task.id.toUpperCase()));
+  const foundIds = new Set(found.map((task) => task.id.toUpperCase()));
+  const missing = normalized.filter((id) => !foundIds.has(id));
+  if (missing.length > 0) {
+    throw new ChangeCommandError("task_not_found", `No matching task found: ${missing.join(", ")}`, { missing, availableTaskIds });
+  }
+  return { selector, tasks: found, availableTaskIds, availableScopes };
+}
+function deriveTaskRepoIds(task) {
+  return unique([
+    ...parseRepoList(task.primaryRepo),
+    ...task.repos
+  ]);
+}
+function parseTaskFields(block) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of block.split("\n")) {
+    const match = line.match(/^([A-Za-z][A-Za-z ]+):\s*(.*)$/);
+    if (!match) {
+      continue;
+    }
+    fields.set(match[1].trim().toLowerCase(), cleanValue(match[2]));
+  }
+  return fields;
+}
+function parseRepoList(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((part) => cleanValue(part)).filter((part) => part.length > 0 && !isNoRepoValue(part));
+}
+function cleanValue(value) {
+  return value.trim().replace(/^`+|`+$/g, "").trim();
+}
+function isNoRepoValue(value) {
+  const normalized = value.toLowerCase();
+  return normalized === "none" || normalized === "n/a" || normalized === "not applicable" || normalized === "-";
+}
+function unique(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+
+// src/lib/task-prepare.ts
+async function prepareTasks(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const context = await activeChangeContext({ cwd: options.cwd, now, sessionPath: options.sessionPath });
+  const branch = context.change.branch;
+  const tasks = await loadTasksForChange(context.change.changePath);
+  const selection = selectTasks(tasks, options.selector);
+  const selector = formatSelector(options.selector);
+  const selectedTasks = selection.tasks.map((task) => ({ id: task.id, title: task.title, scope: task.scope }));
+  const blockers = [];
+  const emptySelectionBlocker = selectionBlocker(selection.tasks.length, options.selector);
+  if (emptySelectionBlocker) {
+    blockers.push(emptySelectionBlocker);
+  }
+  const artifactRootBlocker = await artifactRootBranchBlocker(context.target.path, branch);
+  if (artifactRootBlocker) {
+    blockers.push(artifactRootBlocker);
+  }
+  const targets = context.mode === "repo" ? repoModeTargets(context.target.path, selection.tasks) : await workspaceModeTargets(context.target.path, selection.tasks, blockers);
+  const plans = blockers.length === 0 ? await preflightTargets(targets, branch, blockers) : [];
+  if (blockers.length > 0) {
+    return result2({ status: "blocked", context, selector, tasks: selectedTasks, repos: [], blockers });
+  }
+  const repos = await applyPlans(plans, branch);
+  if (repos.length > 0) {
+    await writeExecutionState(context.change.changePath, branch, repos, now);
+  }
+  return result2({ status: "ok", context, selector, tasks: selectedTasks, repos, blockers: [] });
+}
+function repoModeTargets(rootPath, tasks) {
+  if (tasks.length === 0) {
+    return [];
+  }
+  return [{ id: "root", absolutePath: rootPath, relativePath: ".", mode: "repo" }];
+}
+async function workspaceModeTargets(rootPath, tasks, blockers) {
+  const metadata = await readWorkspaceMetadata(rootPath);
+  if (!metadata) {
+    blockers.push({ target: rootPath, reason: "Workspace metadata is missing or invalid." });
+    return [];
+  }
+  const repoIds = [];
+  for (const task of tasks) {
+    const taskRepoIds = deriveTaskRepoIds(task).filter((repoId) => repoId.toLowerCase() !== "workspace");
+    if (taskRepoIds.length === 0) {
+      blockers.push({ target: task.id, reason: "Task has no concrete repo metadata for workspace prepare." });
+      continue;
+    }
+    for (const repoId of taskRepoIds) {
+      if (!repoIds.includes(repoId)) {
+        repoIds.push(repoId);
+      }
+    }
+  }
+  const targets = [];
+  for (const repoId of repoIds) {
+    const entry = metadata.repos[repoId];
+    if (!entry) {
+      blockers.push({ target: repoId, reason: "Task references a repo id that is not registered in workspace metadata." });
+      continue;
+    }
+    const absolutePath = path12.join(rootPath, entry.path);
+    if (!await pathExists(absolutePath)) {
+      blockers.push({ target: repoId, reason: `Registered repo path does not exist: ${entry.path}` });
+      continue;
+    }
+    targets.push({ id: repoId, absolutePath, relativePath: entry.path, mode: "workspace" });
+  }
+  return targets;
+}
+function selectionBlocker(taskCount, selector) {
+  if (taskCount > 0) {
+    return void 0;
+  }
+  if (selector.type === "scope") {
+    return { target: selector.scope, reason: "No tasks matched the requested scope." };
+  }
+  if (selector.type === "all") {
+    return { target: "all", reason: "No T# tasks were found in tasks.md." };
+  }
+  return void 0;
+}
+async function artifactRootBranchBlocker(rootPath, branch) {
+  const gitRoot = await findGitRoot(rootPath);
+  if (!gitRoot) {
+    return void 0;
+  }
+  const current = await currentBranch(rootPath);
+  if (!current) {
+    return { target: rootPath, reason: "Artifact root is in detached HEAD or has no current branch." };
+  }
+  if (current !== branch) {
+    return { target: rootPath, reason: `Artifact root branch is ${current}; expected ${branch}.` };
+  }
+  return void 0;
+}
+async function preflightTargets(targets, branch, blockers) {
+  const plans = [];
+  for (const target of targets) {
+    const gitRoot = await findGitRoot(target.absolutePath);
+    if (!gitRoot) {
+      plans.push({ ...target, state: "skipped", branchStatus: "skipped_not_git" });
+      continue;
+    }
+    const current = await currentBranch(target.absolutePath);
+    if (!current) {
+      blockers.push({ target: target.id, reason: "Repo is in detached HEAD or has no current branch." });
+      continue;
+    }
+    if (current === branch) {
+      plans.push({ ...target, state: "prepared", branchStatus: "already_active" });
+      continue;
+    }
+    if (await isWorktreeDirty(target.absolutePath)) {
+      blockers.push({ target: target.id, reason: `Repo has uncommitted changes on ${current}; expected ${branch}.` });
+      continue;
+    }
+    plans.push({
+      ...target,
+      state: "prepared",
+      branchStatus: await branchExists(target.absolutePath, branch) ? "checked_out" : "created"
+    });
+  }
+  return blockers.length > 0 ? [] : plans;
+}
+async function applyPlans(plans, branch) {
+  const repos = [];
+  for (const plan of plans) {
+    if (plan.branchStatus === "checked_out") {
+      await checkoutBranch(plan.absolutePath, branch);
+    } else if (plan.branchStatus === "created") {
+      await createBranch(plan.absolutePath, branch);
+    }
+    const head = plan.state === "prepared" ? await currentHead(plan.absolutePath) : void 0;
+    repos.push({
+      id: plan.id,
+      path: plan.relativePath,
+      mode: plan.mode,
+      state: plan.state,
+      branch_status: plan.branchStatus,
+      branch,
+      ...head ? { prepared_head: head } : {}
+    });
+  }
+  return repos;
+}
+async function writeExecutionState(changePath, branch, repos, now) {
+  const statusPath = path12.join(changePath, "status.yml");
+  const raw = YAML9.parse(await readFile13(statusPath, "utf8"));
+  const existingExecution = isRecord2(raw.execution) ? raw.execution : void 0;
+  const existingBranch = typeof existingExecution?.branch === "string" ? existingExecution.branch : void 0;
+  const preserveExisting = existingBranch === branch && isRecord2(existingExecution?.repos);
+  const existingRepos = preserveExisting ? existingExecution?.repos : {};
+  const nextRepos = { ...existingRepos };
+  const timestamp = now.toISOString();
+  for (const repo of repos) {
+    const existing = isRecord2(nextRepos[repo.id]) ? nextRepos[repo.id] : void 0;
+    const existingPreparedAt = existing?.branch === branch && typeof existing.prepared_at === "string" ? existing.prepared_at : void 0;
+    nextRepos[repo.id] = {
+      path: repo.path,
+      mode: repo.mode,
+      branch: repo.branch,
+      state: repo.state,
+      branch_status: repo.branch_status,
+      ...repo.prepared_head ? { prepared_head: repo.prepared_head } : {},
+      prepared_at: existingPreparedAt ?? timestamp,
+      verified_at: timestamp
+    };
+  }
+  raw.execution = {
+    version: 1,
+    branch,
+    repos: nextRepos
+  };
+  raw.updated_at = timestamp;
+  await writeFile5(statusPath, YAML9.stringify(raw));
+}
+function result2(input) {
+  const value = {
+    status: input.status,
+    change: { id: input.context.change.id, branch: input.context.change.branch, path: input.context.change.path },
+    selector: input.selector,
+    mode: input.context.mode,
+    tasks: input.tasks,
+    repos: input.repos,
+    blockers: input.blockers,
+    message: ""
+  };
+  value.message = formatPrepareMessage(value);
+  return value;
+}
+function formatSelector(selector) {
+  if (selector.type === "all") {
+    return { type: "all" };
+  }
+  if (selector.type === "scope") {
+    return { type: "scope", value: selector.scope };
+  }
+  return { type: "tasks", values: selector.ids };
+}
+function formatPrepareMessage(result3) {
+  const lines = [
+    `Task prepare: ${result3.change.id}`,
+    `Branch: ${result3.change.branch}`,
+    `Mode: ${result3.mode}`,
+    `Status: ${result3.status}`
+  ];
+  if (result3.tasks.length > 0) {
+    lines.push(`Tasks: ${result3.tasks.map((task) => task.id).join(", ")}`);
+  }
+  if (result3.repos.length > 0) {
+    lines.push("", "Repos:", ...result3.repos.map((repo) => `  ${repo.id}  ${repo.branch_status}  ${repo.path}`));
+  }
+  if (result3.blockers.length > 0) {
+    lines.push("", "Blockers:", ...result3.blockers.map((blocker) => `  ${blocker.target}: ${blocker.reason}`));
+  }
+  return lines.join("\n");
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/commands/task.ts
+function taskCommand() {
+  const command = new Command8("task").description("Prepare and inspect Weave local tasks.");
+  command.command("prepare").description("Prepare local branches for selected tasks.").argument("[tasks...]", "task ids, e.g. T1 T3").option("--scope <scope>", "prepare repos referenced by tasks with this scope").option("--all", "prepare repos referenced by all T# tasks").option("--json", "print machine-readable JSON").action(async (tasks, options) => {
+    await runAction5(options.json ?? false, async () => {
+      const selector = parsePrepareSelector(tasks, options);
+      const result3 = await prepareTasks({ cwd: process.cwd(), selector });
+      writeResult3(result3, options.json ?? false);
+      if (result3.status === "blocked") {
+        process.exitCode = 1;
+      }
+    });
+  });
+  return command;
+}
+function parsePrepareSelector(tasks, options) {
+  const hasTasks = tasks.length > 0;
+  const hasScope = typeof options.scope === "string" && options.scope.trim().length > 0;
+  const hasAll = options.all === true;
+  const modes = [hasTasks, hasScope, hasAll].filter(Boolean).length;
+  if (modes !== 1) {
+    throw new InvalidArgumentError4("Provide exactly one selector: task ids, --scope <scope>, or --all.");
+  }
+  if (hasAll) {
+    return { type: "all" };
+  }
+  if (hasScope) {
+    return { type: "scope", scope: options.scope?.trim() ?? "" };
+  }
+  return { type: "tasks", ids: tasks.map((task) => task.toUpperCase()) };
+}
+function writeResult3(result3, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result3, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${result3.message}
+`);
+}
+async function runAction5(json, action) {
+  try {
+    await action();
+  } catch (error) {
+    if (json) {
+      process.stdout.write(`${JSON.stringify(errorResult3(error), null, 2)}
+`);
+    } else {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+function errorResult3(error) {
+  if (error instanceof ChangeCommandError) {
+    return {
+      status: "error",
+      code: error.code,
+      message: error.message,
+      details: error.details
+    };
+  }
+  if (error instanceof InvalidArgumentError4) {
+    return {
+      status: "error",
+      code: "invalid_arguments",
+      message: error.message
+    };
+  }
+  return {
+    status: "error",
+    code: "unknown_error",
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+
+// src/commands/workspace.ts
+import { Command as Command9 } from "commander";
+
+// src/lib/show-workspace.ts
+import path13 from "path";
+async function showWorkspace(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const sessionPath = options.sessionPath ?? defaultSessionPath();
+  const session = await loadCurrentSession(sessionPath);
+  const modeResult = await findWorkspaceMode(cwd);
+  if (isWorkspaceMode(modeResult)) {
+    return buildWorkspaceModeResult({
+      workspacePath: modeResult.workspacePath,
+      session,
+      json: options.json ?? false
+    });
+  }
+  return buildRepoModeResult({ session, json: options.json ?? false });
+}
+async function buildWorkspaceModeResult(input) {
+  const metadata = await readWorkspaceMetadata(input.workspacePath);
+  const summary = workspaceSummary(input.workspacePath, metadata);
+  const repos = metadata ? await reposWithAvailability(input.workspacePath, listReposForDisplay(metadata)) : [];
+  const json = {
+    session: sessionJson(input.session),
+    workspace: summary,
+    repos,
+    folders: []
+  };
+  const text2 = workspaceText(summary, repos);
+  return {
+    status: "ok",
+    message: input.json ? JSON.stringify(json, null, 2) : text2,
+    json,
+    text: text2
+  };
+}
+function buildRepoModeResult(input) {
+  if (!input.session) {
+    const json2 = {
+      session: null,
+      workspace: null,
+      repos: [],
+      folders: []
+    };
+    const text3 = "No current Weave session found. Run `weave init` first.";
+    return {
+      status: "no_session",
+      message: input.json ? JSON.stringify(json2, null, 2) : text3,
+      json: json2,
+      text: text3
+    };
+  }
+  const folders = Object.entries(input.session.folders).map(
+    ([id, folder]) => buildFolderOutput(id, folder.path, folder.kind)
+  );
+  const json = {
+    session: sessionJson(input.session),
+    workspace: null,
+    repos: [],
+    folders
+  };
+  const text2 = repoText(folders);
+  return {
+    status: "ok",
+    message: input.json ? JSON.stringify(json, null, 2) : text2,
+    json,
+    text: text2
+  };
+}
+function buildFolderOutput(id, folderPath, kind) {
+  return {
+    id,
+    path: folderPath,
+    kind,
+    wiki: path13.join(folderPath, "wiki"),
+    metadata: path13.join(folderPath, ".weave")
+  };
+}
+function sessionJson(session) {
+  if (!session) {
+    return null;
+  }
+  return {
+    status: "active",
+    updated_at: session.updated_at
+  };
+}
+function workspaceSummary(workspacePath, metadata) {
+  return {
+    name: metadata?.name ?? path13.basename(workspacePath),
+    path: workspacePath,
+    mode: "workspace"
+  };
+}
+async function reposWithAvailability(workspacePath, repos) {
+  return Promise.all(
+    repos.map(async (repo) => ({
+      ...repo,
+      availability: await pathExists(path13.join(workspacePath, repo.path)) ? "present" : "missing"
+    }))
+  );
+}
+function workspaceText(summary, repos) {
+  const repoLines = repos.length === 0 ? "  (no repos registered yet)" : repos.map((repo) => {
+    const remoteSuffix = repo.remote ? `  ${repo.remote}` : "";
+    return `  ${repo.id}  ${repo.path}  ${repo.kind}  ${repo.availability}${remoteSuffix}`;
+  }).join("\n");
+  return `Weave workspace: ${summary.name}
+
+Path:
+  ${summary.path}
+
+Repos:
+${repoLines}
+
+Next:
+  weave add <path|url>
+  weave change new <title>`;
+}
+function repoText(folders) {
+  const folderLines = folders.map((folder) => `  ${folder.id}  ${folder.path}  ${folder.kind}`).join("\n");
+  return `Current Weave session
+
+Folders:
+${folderLines}
+
+Next:
+  weave add <path>
+  weave init`;
+}
+
+// src/commands/workspace.ts
+function workspaceCommand() {
+  return new Command9("workspace").description("Show the current Weave workspace (workspace mode) or session folders (repo mode).").option("--json", "print machine-readable JSON").action(async (options) => {
+    await withNotices(
+      { commandName: "workspace", json: options.json ?? false },
+      async () => {
+        const result3 = await showWorkspace({ cwd: process.cwd() });
+        return {
+          json: result3.json,
+          text: result3.text,
+          exitCode: result3.status === "no_session" ? 1 : 0
+        };
+      }
+    );
+  });
+}
+
+// src/cli.ts
+import { pathToFileURL } from "url";
+function createProgram() {
+  const program = new Command10();
+  program.name("weave").description("Repo-local LLM wiki and temporary multi-folder AI session tooling.").version("0.1.0");
+  program.addCommand(initCommand());
+  program.addCommand(addCommand());
+  program.addCommand(workspaceCommand());
+  program.addCommand(changeCommand());
+  program.addCommand(artifactCommand());
+  program.addCommand(agentCommand());
+  program.addCommand(skillsCommand());
+  program.addCommand(skillCommand());
+  program.addCommand(statusCommand());
+  program.addCommand(taskCommand());
+  return program;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await createProgram().parseAsync(process.argv);
+}
+export {
+  createProgram
+};
+//# sourceMappingURL=cli.js.map