@driftless-sh/cli 0.1.24 → 0.1.26

package/dist/index.js

@@ -23019,8 +23019,8 @@ ${lanes.join("\n")}
       function containsInvalidEscapeFlag(node) {
         return !!((node.templateFlags || 0) & 2048);
       }
-      function hasInvalidEscape(template2) {
-        return template2 && !!(isNoSubstitutionTemplateLiteral(template2) ? containsInvalidEscapeFlag(template2) : containsInvalidEscapeFlag(template2.head) || some(template2.templateSpans, (span) => containsInvalidEscapeFlag(span.literal)));
+      function hasInvalidEscape(template) {
+        return template && !!(isNoSubstitutionTemplateLiteral(template) ? containsInvalidEscapeFlag(template) : containsInvalidEscapeFlag(template.head) || some(template.templateSpans, (span) => containsInvalidEscapeFlag(span.literal)));
       }
       var doubleQuoteEscapedCharsRegExp = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g;
       var singleQuoteEscapedCharsRegExp = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g;
@@ -30345,7 +30345,7 @@ ${lanes.join("\n")}
         function updateNewExpression(node, expression, typeArguments, argumentsArray) {
           return node.expression !== expression || node.typeArguments !== typeArguments || node.arguments !== argumentsArray ? update(createNewExpression(expression, typeArguments, argumentsArray), node) : node;
         }
-        function createTaggedTemplateExpression(tag, typeArguments, template2) {
+        function createTaggedTemplateExpression(tag, typeArguments, template) {
           const node = createBaseNode(
             216
             /* TaggedTemplateExpression */
@@ -30356,7 +30356,7 @@ ${lanes.join("\n")}
             false
           );
           node.typeArguments = asNodeArray(typeArguments);
-          node.template = template2;
+          node.template = template;
           node.transformFlags |= propagateChildFlags(node.tag) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.template) | 1024;
           if (node.typeArguments) {
             node.transformFlags |= 1;
@@ -30366,8 +30366,8 @@ ${lanes.join("\n")}
           }
           return node;
         }
-        function updateTaggedTemplateExpression(node, tag, typeArguments, template2) {
-          return node.tag !== tag || node.typeArguments !== typeArguments || node.template !== template2 ? update(createTaggedTemplateExpression(tag, typeArguments, template2), node) : node;
+        function updateTaggedTemplateExpression(node, tag, typeArguments, template) {
+          return node.tag !== tag || node.typeArguments !== typeArguments || node.template !== template ? update(createTaggedTemplateExpression(tag, typeArguments, template), node) : node;
         }
         function createTypeAssertion(type, expression) {
           const node = createBaseNode(
@@ -73219,14 +73219,14 @@ ${lanes.join("\n")}
             while (i > 0) {
               i--;
               const t = types[i];
-              if (t.flags & 128 && some(templates, (template2) => isTypeMatchedByTemplateLiteralOrStringMapping(t, template2))) {
+              if (t.flags & 128 && some(templates, (template) => isTypeMatchedByTemplateLiteralOrStringMapping(t, template))) {
                 orderedRemoveItemAt(types, i);
               }
             }
           }
         }
-        function isTypeMatchedByTemplateLiteralOrStringMapping(type, template2) {
-          return template2.flags & 134217728 ? isTypeMatchedByTemplateLiteralType(type, template2) : isMemberOfStringMapping(type, template2);
+        function isTypeMatchedByTemplateLiteralOrStringMapping(type, template) {
+          return template.flags & 134217728 ? isTypeMatchedByTemplateLiteralType(type, template) : isMemberOfStringMapping(type, template);
         }
         function removeConstrainedTypeVariables(types) {
           const typeVariables = [];
@@ -85395,9 +85395,9 @@ ${lanes.join("\n")}
           const signature = getDecoratorCallSignature(decorator);
           return signature ? getOrCreateTypeFromSignature(signature) : void 0;
         }
-        function getContextualTypeForSubstitutionExpression(template2, substitutionExpression) {
-          if (template2.parent.kind === 216) {
-            return getContextualTypeForArgument(template2.parent, substitutionExpression);
+        function getContextualTypeForSubstitutionExpression(template, substitutionExpression) {
+          if (template.parent.kind === 216) {
+            return getContextualTypeForArgument(template.parent, substitutionExpression);
           }
           return void 0;
         }
@@ -89022,10 +89022,10 @@ ${lanes.join("\n")}
             return [createSyntheticExpression(node, emptyFreshJsxObjectType)];
           }
           if (node.kind === 216) {
-            const template2 = node.template;
-            const args2 = [createSyntheticExpression(template2, getGlobalTemplateStringsArrayType())];
-            if (template2.kind === 229) {
-              forEach(template2.templateSpans, (span) => {
+            const template = node.template;
+            const args2 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())];
+            if (template.kind === 229) {
+              forEach(template.templateSpans, (span) => {
                 args2.push(span.expression);
               });
             }
@@ -107909,18 +107909,18 @@ ${lanes.join("\n")}
         const templateArguments = [void 0];
         const cookedStrings = [];
         const rawStrings = [];
-        const template2 = node.template;
-        if (level === 0 && !hasInvalidEscape(template2)) {
+        const template = node.template;
+        if (level === 0 && !hasInvalidEscape(template)) {
           return visitEachChild(node, visitor, context);
         }
         const { factory: factory2 } = context;
-        if (isNoSubstitutionTemplateLiteral(template2)) {
-          cookedStrings.push(createTemplateCooked(factory2, template2));
-          rawStrings.push(getRawLiteral(factory2, template2, currentSourceFile));
+        if (isNoSubstitutionTemplateLiteral(template)) {
+          cookedStrings.push(createTemplateCooked(factory2, template));
+          rawStrings.push(getRawLiteral(factory2, template, currentSourceFile));
         } else {
-          cookedStrings.push(createTemplateCooked(factory2, template2.head));
-          rawStrings.push(getRawLiteral(factory2, template2.head, currentSourceFile));
-          for (const templateSpan of template2.templateSpans) {
+          cookedStrings.push(createTemplateCooked(factory2, template.head));
+          rawStrings.push(getRawLiteral(factory2, template.head, currentSourceFile));
+          for (const templateSpan of template.templateSpans) {
             cookedStrings.push(createTemplateCooked(factory2, templateSpan.literal));
             rawStrings.push(getRawLiteral(factory2, templateSpan.literal, currentSourceFile));
             templateArguments.push(Debug.checkDefined(visitNode(templateSpan.expression, visitor, isExpression)));
@@ -107950,8 +107950,8 @@ ${lanes.join("\n")}
           templateArguments
         );
       }
-      function createTemplateCooked(factory2, template2) {
-        return template2.templateFlags & 26656 ? factory2.createVoidZero() : factory2.createStringLiteral(template2.text);
+      function createTemplateCooked(factory2, template) {
+        return template.templateFlags & 26656 ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
       }
       function getRawLiteral(factory2, node, currentSourceFile) {
         let text = node.rawText;
@@ -114494,13 +114494,13 @@ ${lanes.join("\n")}
             const boundTag = factory2.createFunctionBindCall(tag, classThis, []);
             setOriginalNode(boundTag, node);
             setTextRange(boundTag, node);
-            const template2 = visitNode(node.template, visitor, isTemplateLiteral);
+            const template = visitNode(node.template, visitor, isTemplateLiteral);
             return factory2.updateTaggedTemplateExpression(
               node,
               boundTag,
               /*typeArguments*/
               void 0,
-              template2
+              template
             );
           }
           return visitEachChild(node, visitor, context);
@@ -146943,7 +146943,7 @@ ${lanes.join("\n")}
         };
       }
       function createBuildOrUpdateInvalidedProject(state, project, projectPath, projectIndex, config, status, buildOrder) {
-        let step = 0;
+        let step2 = 0;
         let program;
         let buildResult;
         return {
@@ -147019,14 +147019,14 @@ ${lanes.join("\n")}
           if (state.options.dry) {
             reportStatus(state, Diagnostics.A_non_dry_build_would_build_project_0, project);
             buildResult = 1;
-            step = 2;
+            step2 = 2;
             return;
           }
           if (state.options.verbose) reportStatus(state, Diagnostics.Building_project_0, project);
           if (config.fileNames.length === 0) {
             reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
             buildResult = 0;
-            step = 2;
+            step2 = 2;
             return;
           }
           const { host, compilerHost } = state;
@@ -147052,13 +147052,13 @@ ${lanes.join("\n")}
             );
             state.builderPrograms.set(projectPath, program);
           }
-          step++;
+          step2++;
         }
         function emit(writeFileCallback, cancellationToken, customTransformers) {
           var _a, _b, _c;
           Debug.assertIsDefined(program);
           Debug.assert(
-            step === 1
+            step2 === 1
             /* Emit */
           );
           const { host, compilerHost } = state;
@@ -147130,13 +147130,13 @@ ${lanes.join("\n")}
             buildResult |= 4;
           }
           afterProgramDone(state, program);
-          step = 2;
+          step2 = 2;
           return emitResult;
         }
         function executeSteps(till, cancellationToken, writeFile2, customTransformers) {
-          while (step <= till && step < 3) {
-            const currentStep = step;
-            switch (step) {
+          while (step2 <= till && step2 < 3) {
+            const currentStep = step2;
+            switch (step2) {
               case 0:
                 createProgram2();
                 break;
@@ -147145,14 +147145,14 @@ ${lanes.join("\n")}
                 break;
               case 2:
                 queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult));
-                step++;
+                step2++;
                 break;
               // Should never be done
               case 3:
               default:
-                assertType(step);
+                assertType(step2);
             }
-            Debug.assert(step > currentStep);
+            Debug.assert(step2 > currentStep);
           }
         }
       }
@@ -159531,12 +159531,12 @@ interface Symbol {
             void 0,
             typeParameter.name
           );
-          const template2 = factory.createJSDocTemplateTag(
+          const template = factory.createJSDocTemplateTag(
             factory.createIdentifier("template"),
             constraint && cast(constraint, isJSDocTypeExpression),
             [parameter]
           );
-          templates.push(template2);
+          templates.push(template);
         });
         const jsDoc = factory.createJSDocComment(
           /*comment*/
@@ -191190,11 +191190,11 @@ ${content}
         return createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
       }
       function getApplicableSpanForTaggedTemplate(taggedTemplate, sourceFile) {
-        const template2 = taggedTemplate.template;
-        const applicableSpanStart = template2.getStart();
-        let applicableSpanEnd = template2.getEnd();
-        if (template2.kind === 229) {
-          const lastSpan = last(template2.templateSpans);
+        const template = taggedTemplate.template;
+        const applicableSpanStart = template.getStart();
+        let applicableSpanEnd = template.getEnd();
+        if (template.kind === 229) {
+          const lastSpan = last(template.templateSpans);
           if (lastSpan.literal.getFullWidth() === 0) {
             applicableSpanEnd = skipTrivia(
               sourceFile.text,
@@ -214431,8 +214431,119 @@ function formatError(e) {
 // src/commands/init.ts
 init_git();
 var import_scanner = __toESM(require_dist());
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
+
+// src/commands/install-skill.ts
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
+var SKILL_URL = "https://raw.githubusercontent.com/driftless-gh/driftless-skill/main/skills/driftless/SKILL.md";
+var AGENTS_BLOCK = `
+## Driftless \u2014 Context Integrity
+
+Before touching files:
+  driftless context push --files "<files you're about to edit>"
+
+Before pushing:
+  driftless scan --diff
+
+Save discoveries:
+  driftless context update <slug> --gotchas "..." --decisions "..."
+
+Full skill \u2192 https://github.com/driftless-gh/driftless-skill
+`;
+async function downloadSkill(cwd) {
+  const driftlessDir = (0, import_node_path3.resolve)(cwd, ".driftless");
+  if (!(0, import_node_fs3.existsSync)(driftlessDir)) {
+    (0, import_node_fs3.mkdirSync)(driftlessDir, { recursive: true });
+  }
+  const skillPath = (0, import_node_path3.resolve)(driftlessDir, "skill.md");
+  try {
+    const { default: https } = await import("node:https");
+    const { default: http } = await import("node:http");
+    const url = new URL(SKILL_URL);
+    const client = url.protocol === "https:" ? https : http;
+    await new Promise((ok, fail) => {
+      client.get(SKILL_URL, (res) => {
+        if (res.statusCode !== 200) {
+          fail(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          (0, import_node_fs3.writeFileSync)(skillPath, Buffer.concat(chunks), "utf-8");
+          ok();
+        });
+        res.on("error", fail);
+      }).on("error", fail);
+    });
+  } catch {
+    (0, import_node_fs3.writeFileSync)(
+      skillPath,
+      `# Driftless Skill
+
+See https://github.com/driftless-gh/driftless-skill for the full skill.
+`,
+      "utf-8"
+    );
+  }
+}
+function handleClaudeMd(cwd) {
+  const claudePath = (0, import_node_path3.resolve)(cwd, "CLAUDE.md");
+  const reference = "@.driftless/skill.md";
+  if (!(0, import_node_fs3.existsSync)(claudePath)) {
+    (0, import_node_fs3.writeFileSync)(claudePath, `${reference}
+`, "utf-8");
+    return "created";
+  }
+  const existing = (0, import_node_fs3.readFileSync)(claudePath, "utf-8");
+  if (existing.includes(reference)) {
+    return "already configured";
+  }
+  const needsNewline = existing.length > 0 && !existing.endsWith("\n");
+  (0, import_node_fs3.writeFileSync)(claudePath, existing + (needsNewline ? "\n" : "") + `
+${reference}
+`, "utf-8");
+  return "updated";
+}
+function handleAgentsMd(cwd) {
+  const agentsPath = (0, import_node_path3.resolve)(cwd, "AGENTS.md");
+  if (!(0, import_node_fs3.existsSync)(agentsPath)) {
+    (0, import_node_fs3.writeFileSync)(agentsPath, AGENTS_BLOCK.trimStart(), "utf-8");
+    return "created";
+  }
+  const existing = (0, import_node_fs3.readFileSync)(agentsPath, "utf-8");
+  if (existing.includes("## Driftless")) {
+    return "already configured";
+  }
+  const needsNewline = existing.length > 0 && !existing.endsWith("\n");
+  (0, import_node_fs3.writeFileSync)(agentsPath, existing + (needsNewline ? "\n" : "") + AGENTS_BLOCK, "utf-8");
+  return "updated";
+}
+async function runInstallSkill(cwd) {
+  await downloadSkill(cwd);
+  const claudeMd = handleClaudeMd(cwd);
+  const agentsMd = handleAgentsMd(cwd);
+  return { claudeMd, agentsMd };
+}
+async function installSkillCommand() {
+  const cwd = process.cwd();
+  const result = await runInstallSkill(cwd);
+  const icon = (s) => s === "created" ? "created \u2713" : s === "updated" ? "updated \u2713" : "already configured \u2713";
+  console.log(`  CLAUDE.md   ${icon(result.claudeMd)}`);
+  console.log(`  AGENTS.md   ${icon(result.agentsMd)}`);
+  return result;
+}
+
+// src/commands/init.ts
+function getVersion() {
+  try {
+    return "0.1.26";
+  } catch {
+    return "0.0.0";
+  }
+}
 function analyzeCodePatterns(components) {
   const pattern = {
     guardNames: [],
@@ -214690,15 +214801,15 @@ function detectExistingDocs(cwd) {
     { path: "README.md", name: "readme", what: "Project overview and setup", pattern: void 0 }
   ];
   for (const candidate of candidates) {
-    const fullPath = (0, import_node_path3.resolve)(cwd, candidate.path);
-    if ((0, import_node_fs3.existsSync)(fullPath)) {
+    const fullPath = (0, import_node_path4.resolve)(cwd, candidate.path);
+    if ((0, import_node_fs4.existsSync)(fullPath)) {
       docs.push({ path: candidate.path, name: candidate.name, what: candidate.what, pattern: candidate.pattern });
     }
   }
-  const docsDir = (0, import_node_path3.resolve)(cwd, "docs");
-  if ((0, import_node_fs3.existsSync)(docsDir)) {
+  const docsDir = (0, import_node_path4.resolve)(cwd, "docs");
+  if ((0, import_node_fs4.existsSync)(docsDir)) {
     try {
-      const entries = (0, import_node_fs3.readdirSync)(docsDir, { withFileTypes: true });
+      const entries = (0, import_node_fs4.readdirSync)(docsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith(".md")) {
           const existingPath = candidates.find((c) => c.path === `docs/${entry.name}`);
@@ -214718,8 +214829,23 @@ function detectExistingDocs(cwd) {
   }
   return docs;
 }
+var DIVIDER = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+var DOT_TOTAL = 36;
+function step(label, value) {
+  const prefix = `  \u2192 ${label}`;
+  const dots = ".".repeat(Math.max(2, DOT_TOTAL - prefix.length));
+  console.log(`${prefix}${dots}  ${value}`);
+}
 async function initCommand(args) {
-  console.log("Driftless \u2014 context integrity for engineering teams\n");
+  const version = getVersion();
+  console.log("D R I F T L E S S");
+  console.log(`v${version}`);
+  console.log("");
+  console.log("AI ships fast. Humans lose context faster.");
+  console.log("Driftless fixes that.");
+  console.log("");
+  console.log(DIVIDER);
+  console.log("");
   if (!isGitRepo()) {
     console.error("Error: not a git repository.");
     process.exit(1);
@@ -214729,8 +214855,6 @@ async function initCommand(args) {
     console.error("Error: no git remote found.");
     process.exit(1);
   }
-  console.log(`Repository: ${remote.org}/${remote.repo}`);
-  console.log("\nConnecting to Driftless Cloud...");
   let workspace;
   try {
     workspace = await api.get("/me");
@@ -214738,15 +214862,18 @@ async function initCommand(args) {
       console.error("Could not resolve workspace. Check your API key.");
       process.exit(1);
     }
-    console.log(`  Workspace: ${workspace.slug} \u2713`);
   } catch (err) {
-    console.error(`  Failed: ${err?.message || "unreachable"}`);
+    console.error(`Failed to connect: ${err?.message || "unreachable"}`);
     process.exit(1);
   }
   const workspaceSlug = workspace.slug;
-  console.log("\nScanning codebase locally...");
+  console.log(`Repository: ${remote.org}/${remote.repo}`);
+  console.log(`Workspace:  ${workspaceSlug} \u2713`);
+  console.log("");
   const cwd = process.cwd();
+  const scanStart = Date.now();
   const scanResult = await (0, import_scanner.scanRepo)(cwd);
+  const scanMs = Date.now() - scanStart;
   const earlyPatterns = analyzeCodePatterns(scanResult.components);
   const summary = {
     endpoints: scanResult.stats.total_endpoints,
@@ -214773,36 +214900,31 @@ async function initCommand(args) {
   const actualServices = components.filter((c) => c.type === "service").length;
   const actualModules = components.filter((c) => c.type === "module").length;
   const actualGuards = components.filter((c) => c.type === "guard").length;
-  const actualControllers = components.filter((c) => c.type === "controller").length;
-  const actualDtos = components.filter((c) => c.type === "dto").length;
-  console.log(`  Framework: ${summary.framework}  |  Endpoints: ${actualEndpoints}  |  Services: ${actualServices}`);
-  console.log(`  Modules: ${actualModules}  |  Guards: ${actualGuards}`);
-  console.log(`  Relations: ${relationCount}`);
-  if (actualControllers > 0) console.log(`  Controllers: ${actualControllers}`);
-  if (actualDtos > 0) console.log(`  DTOs: ${actualDtos}`);
-  if (summary.auth_patterns.length > 0) {
-    console.log(`  Auth: ${summary.auth_patterns.join(", ")}`);
-  }
-  if (scanResult.telemetry) {
-    const t = scanResult.telemetry;
-    console.log(`  Scan: ${t.duration_ms}ms, ${t.memory_mb}MB heap, ${t.files_parsed} files`);
+  const frameworkLabel = [summary.framework, "ts"].filter(Boolean).join(", ");
+  step("detecting framework", frameworkLabel);
+  step("extracting components", `${components.length} found`);
+  step("mapping relations", `${relationCount} mapped`);
+  const patternsLabel = `${actualGuards} guard${actualGuards !== 1 ? "s" : ""} \xB7 ${actualEndpoints} endpoints`;
+  step("analyzing patterns", patternsLabel);
+  const telemetry = scanResult.telemetry;
+  if (telemetry) {
+    console.log(`  Scan: ${telemetry.duration_ms}ms \xB7 ${telemetry.memory_mb}MB \xB7 ${telemetry.files_parsed} files`);
+  } else {
+    console.log(`  Scan: ${scanMs}ms`);
   }
+  console.log("");
   let repo;
   try {
     const repos = await api.get(`/workspaces/${workspaceSlug}/repos`);
     repo = Array.isArray(repos) ? repos.find((r) => r.github_org === remote.org && r.github_repo === remote.repo) : null;
   } catch {
   }
-  if (repo) {
-    console.log(`
-  Repo: ${remote.repo} \u2713`);
-  } else {
+  if (!repo) {
     try {
       repo = await api.post(`/workspaces/${workspaceSlug}/repos`, {
         github_org: remote.org,
         github_repo: remote.repo
       });
-      console.log(`  Repo: ${remote.repo} (connected)`);
     } catch (err) {
       console.error(`  Failed to connect repo: ${err?.message || "unknown"}`);
       process.exit(1);
@@ -214810,39 +214932,35 @@ async function initCommand(args) {
   }
   try {
     await api.post(`/workspaces/${workspaceSlug}/repos/${repo.id}/baseline`, summary);
-    console.log("  Baseline uploaded \u2713");
-  } catch (err) {
-    console.error(`  Upload failed: ${err?.message || "unknown"}`);
+    step("uploading baseline", "\u2713");
+  } catch {
+    step("uploading baseline", "failed (continuing)");
   }
   if (components.length > 0) {
     try {
       await api.post(`/workspaces/${workspaceSlug}/repos/${repo.id}/components`, { components });
-      console.log(`  Components uploaded (${components.length}, relations ${relationCount}) \u2713`);
-    } catch (err) {
-      console.error(`  Component upload failed: ${err?.message || "unknown"}`);
+      step("uploading components", `${components.length} components \xB7 ${relationCount} relations \u2713`);
+    } catch {
+      step("uploading components", "failed (continuing)");
     }
   }
-  console.log("\nAnalyzing code patterns...");
   const patterns = earlyPatterns;
   const smartRules = generateSmartRules(repo.id, patterns);
-  console.log(`  Detected: ${patterns.guardNames.length} guards, ${patterns.endpointPaths.length} endpoints`);
-  if (patterns.hasMultiTenant) console.log("  Multi-tenant pattern detected");
-  if (patterns.largeFiles.length > 0) console.log(`  Large files: ${patterns.largeFiles.length} (quarantine candidates)`);
-  if (patterns.quarantineCandidates.length > 0) console.log(`  Legacy files: ${patterns.quarantineCandidates.length}`);
-  console.log(`
-Creating ${smartRules.length} architectural rules...`);
   let rulesCreated = 0;
   let rulesSkipped = 0;
   for (const rule of smartRules) {
     try {
-      await api.post(`/workspaces/${workspaceSlug}/rules`, { ...rule, auto_suggested: true });
-      rulesCreated++;
+      const result = await api.post(`/workspaces/${workspaceSlug}/rules`, { ...rule, auto_suggested: true });
+      if (result?.skipped) {
+        rulesSkipped++;
+      } else {
+        rulesCreated++;
+      }
     } catch {
       rulesSkipped++;
     }
   }
-  console.log(`  Rules created: ${rulesCreated}, skipped (already exist): ${rulesSkipped}`);
-  console.log("\nCreating context watchers from detected modules...");
+  step("creating rules", `${rulesCreated} created \xB7 ${rulesSkipped} skipped \u2713`);
   const smartWatchers = generateSmartWatchers(components);
   let watchersCreated = 0;
   let watchersSkipped = 0;
@@ -214860,19 +214978,17 @@ Creating ${smartRules.length} architectural rules...`);
         created_by: "driftless-init"
       });
       watchersCreated++;
-      console.log(`    \u2713 ${watcher.name} \u2014 ${watcher.what}`);
     } catch {
       watchersSkipped++;
     }
   }
-  console.log(`  Watchers created: ${watchersCreated}, skipped (already exist): ${watchersSkipped}`);
-  console.log("\nScanning for existing documentation...");
+  step("creating context", `${watchersCreated} watchers \u2713`);
   const existingDocs = detectExistingDocs(cwd);
   let docsAnchored = 0;
   for (const doc of existingDocs) {
     try {
-      const fullPath = (0, import_node_path3.resolve)(cwd, doc.path);
-      const fileContent = (0, import_node_fs3.readFileSync)(fullPath, "utf-8");
+      const fullPath = (0, import_node_path4.resolve)(cwd, doc.path);
+      const fileContent = (0, import_node_fs4.readFileSync)(fullPath, "utf-8");
       await api.post(`/workspaces/${workspaceSlug}/watchers`, {
         name: doc.name,
         what: doc.what,
@@ -214885,21 +215001,31 @@ Creating ${smartRules.length} architectural rules...`);
         created_by: "driftless-init"
       });
       docsAnchored++;
-      console.log(`    \u2713 ${doc.name} \u2014 ${doc.path}`);
     } catch {
     }
   }
-  console.log(`  Docs anchored: ${docsAnchored}`);
-  console.log("\n---");
-  console.log(`Architecture: ${actualModules} modules, ${actualEndpoints} endpoints, ${actualServices} services`);
-  console.log(`Relations: ${relationCount} cross-component dependencies mapped`);
-  console.log(`Rules: ${rulesCreated} architectural rules created from code analysis`);
-  console.log(`Watchers: ${watchersCreated} context watchers auto-generated`);
-  console.log(`Docs: ${docsAnchored} existing documents anchored`);
-  console.log(`
-View: https://driftless.icu/ecosystem`);
-  console.log(`Test: driftless scan --diff`);
-  console.log(`Push: driftless context push --files "apps/api/src/auth/auth.controller.ts"`);
+  step("anchoring docs", `${docsAnchored} docs \u2713`);
+  let skillLine = "skipped";
+  try {
+    const skillResult = await runInstallSkill(cwd);
+    const claudeIcon = skillResult.claudeMd === "created" ? "CLAUDE.md created" : skillResult.claudeMd === "updated" ? "CLAUDE.md updated" : "CLAUDE.md ok";
+    const agentsIcon = skillResult.agentsMd === "created" ? "AGENTS.md created" : skillResult.agentsMd === "updated" ? "AGENTS.md updated" : "AGENTS.md ok";
+    skillLine = `${claudeIcon} \xB7 ${agentsIcon} \u2713`;
+  } catch {
+  }
+  step("installing skill", skillLine);
+  console.log("");
+  console.log("\u2713 repo context bootstrapped");
+  console.log(`  \u251C\u2500 watchers      ${watchersCreated}`);
+  console.log(`  \u251C\u2500 rules          ${rulesCreated}`);
+  console.log(`  \u251C\u2500 docs          ${docsAnchored}`);
+  console.log(`  \u251C\u2500 components   ${components.length}`);
+  console.log(`  \u2514\u2500 relations    ${relationCount}`);
+  console.log("");
+  console.log("  dashboard  \u2192  driftless.icu/ecosystem");
+  console.log("  next       \u2192  driftless context list");
+  console.log("");
+  console.log(DIVIDER);
 }
 
 // src/commands/scan.ts
@@ -215015,8 +215141,8 @@ ${result.violations.length} violation(s) found (${rulesEvaluated} rule(s) evalua
 
 // src/commands/context.ts
 init_git();
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
 function parseArgs(args) {
   const flags = {};
   const positional = [];
@@ -215072,6 +215198,7 @@ ${items.length} topic${items.length === 1 ? "" : "s"}.`);
 function renderContextHuman(ctx) {
   console.log(`\u258C ${ctx.topic}`);
   console.log(`  ${ctx.summary}`);
+  if (ctx.version !== void 0) console.log(`  version:    ${ctx.version}`);
   if (ctx.stale.is_stale) {
     console.log(`
   \u26A0 STALE: ${ctx.stale.reason || "Context may be outdated"}`);
@@ -215249,7 +215376,7 @@ async function contextCommand(args) {
         }
         process.exit(0);
       }
-      const missingFiles = files.filter((f) => !(0, import_node_fs4.existsSync)((0, import_node_path4.resolve)(process.cwd(), f)));
+      const missingFiles = files.filter((f) => !(0, import_node_fs5.existsSync)((0, import_node_path5.resolve)(process.cwd(), f)));
       if (missingFiles.length > 0 && !isJSON) {
         console.error(`File(s) not found locally: ${missingFiles.join(", ")}. Matching by pattern only.`);
       }
@@ -215328,7 +215455,7 @@ async function contextCommand(args) {
     let fileContent;
     if (flags["file"]) {
       try {
-        fileContent = (0, import_node_fs4.readFileSync)(flags["file"], "utf-8");
+        fileContent = (0, import_node_fs5.readFileSync)(flags["file"], "utf-8");
       } catch {
         console.error(`File not found: ${flags["file"]}`);
         process.exit(1);
@@ -215493,7 +215620,7 @@ async function contextCommand(args) {
     let fileContent;
     if (docFlag) {
       try {
-        fileContent = (0, import_node_fs4.readFileSync)(docFlag, "utf-8");
+        fileContent = (0, import_node_fs5.readFileSync)(docFlag, "utf-8");
       } catch {
         console.error(`File not found: ${docFlag}`);
         process.exit(1);
@@ -215555,7 +215682,7 @@ async function contextCommand(args) {
       console.error("No files provided.");
       process.exit(1);
     }
-    const missingFiles = files.filter((f) => !(0, import_node_fs4.existsSync)((0, import_node_path4.resolve)(process.cwd(), f)));
+    const missingFiles = files.filter((f) => !(0, import_node_fs5.existsSync)((0, import_node_path5.resolve)(process.cwd(), f)));
     if (missingFiles.length > 0 && !isJSON) {
       console.error(`File(s) not found locally: ${missingFiles.join(", ")}. Matching by pattern only.`);
     }
@@ -215600,14 +215727,21 @@ Warnings:`);
         emitJSON2(results);
       } else {
         if (results.length > 0) {
-          console.log(`Matched ${results.length} topic${results.length === 1 ? "" : "s"}:`);
+          console.log(`Matched ${results.length} context topic${results.length === 1 ? "" : "s"} for ${files.length} file${files.length === 1 ? "" : "s"}:
+`);
           for (const r of results) {
-            console.log(`  ${r.context.topic} via ${r.match_reason}`);
+            try {
+              const fullCtx = await api.get(`/workspaces/${workspaceSlug}/watchers/${r.context.topic}`);
+              renderContextHuman(fullCtx);
+              console.log("");
+            } catch {
+              console.log(`\u258C ${r.context.topic}  (${r.match_reason})`);
+              console.log(`  ${r.context.summary}`);
+              console.log("");
+            }
           }
-          console.log(`
-Context delivered for ${files.length} file${files.length === 1 ? "" : "s"}.`);
         } else {
-          console.log(`No context topics match these files. No watcher covers the changed paths.`);
+          console.log(`No context topics match these files. No context covers the changed paths.`);
         }
       }
     } catch (e) {
@@ -215616,6 +215750,157 @@ Context delivered for ${files.length} file${files.length === 1 ? "" : "s"}.`);
     }
     return;
   }
+  if (subCommand === "export") {
+    const dir = flags["dir"] ?? ".driftless/watchers";
+    const absDir = (0, import_node_path5.resolve)(process.cwd(), dir);
+    try {
+      const summaries = await api.get(`/workspaces/${workspaceSlug}/watchers`);
+      (0, import_node_fs5.mkdirSync)(absDir, { recursive: true });
+      for (const summary of summaries) {
+        const slug = summary.topic;
+        let ctx;
+        try {
+          ctx = await api.get(`/workspaces/${workspaceSlug}/watchers/${slug}`);
+        } catch {
+          console.error(`  skipped ${slug} (fetch failed)`);
+          continue;
+        }
+        const lines = [];
+        const needsQuotes = (s) => /[:#\[\]{}&*!|>'"%@`,]/.test(s) || s.trim() !== s;
+        const safeStr = (s) => needsQuotes(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
+        lines.push(`slug: ${safeStr(slug)}`);
+        if (ctx.version !== void 0) lines.push(`version: ${ctx.version}`);
+        if (ctx.description.what) lines.push(`what: ${safeStr(ctx.description.what)}`);
+        if (ctx.description.how) lines.push(`how: ${safeStr(ctx.description.how)}`);
+        if (ctx.anchors.files.length > 0) {
+          lines.push(`where_files:`);
+          for (const f of ctx.anchors.files) lines.push(`  - ${safeStr(f)}`);
+        }
+        if (ctx.anchors.docs.length > 0 && ctx.anchors.docs[0].path) {
+          lines.push(`anchored_doc: ${safeStr(ctx.anchors.docs[0].path)}`);
+        }
+        if (ctx.description.decisions) lines.push(`decisions: ${safeStr(ctx.description.decisions)}`);
+        if (ctx.description.gotchas.length > 0) {
+          lines.push(`gotchas: ${safeStr(ctx.description.gotchas.join(". "))}`);
+        }
+        if (ctx.description.ownership) lines.push(`ownership: ${safeStr(ctx.description.ownership)}`);
+        const yamlContent = lines.join("\n") + "\n";
+        (0, import_node_fs5.writeFileSync)((0, import_node_path5.join)(absDir, `${slug}.yaml`), yamlContent, "utf-8");
+      }
+      if (!isJSON) {
+        console.log(`Exported ${summaries.length} context topic${summaries.length === 1 ? "" : "s"} \u2192 ${dir}/`);
+      } else {
+        emitJSON2({ exported: summaries.length, dir });
+      }
+    } catch (e) {
+      console.error(`Export failed: ${formatError(e)}`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (subCommand === "import") {
+    const dir = flags["dir"] ?? ".driftless/watchers";
+    const absDir = (0, import_node_path5.resolve)(process.cwd(), dir);
+    if (!(0, import_node_fs5.existsSync)(absDir)) {
+      console.error(`Directory not found: ${dir}`);
+      process.exit(1);
+    }
+    let files;
+    try {
+      files = (0, import_node_fs5.readdirSync)(absDir).filter((f) => f.endsWith(".yaml"));
+    } catch (e) {
+      console.error(`Failed to read directory: ${formatError(e)}`);
+      process.exit(1);
+    }
+    if (files.length === 0) {
+      console.log(`No .yaml files found in ${dir}/`);
+      return;
+    }
+    let created = 0;
+    let updated = 0;
+    for (const file of files) {
+      const filePath = (0, import_node_path5.join)(absDir, file);
+      let raw;
+      try {
+        raw = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
+      } catch {
+        console.error(`  skipped ${file} (read error)`);
+        continue;
+      }
+      const parsed = {};
+      let lastArrayKey = null;
+      for (const line of raw.split("\n")) {
+        if (!line.trim() || line.trim().startsWith("#")) continue;
+        if (/^\s{2,}-\s/.test(line)) {
+          if (lastArrayKey) {
+            const item = line.replace(/^\s{2,}-\s*/, "").trim();
+            const existing = parsed[lastArrayKey];
+            if (Array.isArray(existing)) {
+              existing.push(item);
+            } else {
+              parsed[lastArrayKey] = [item];
+            }
+          }
+          continue;
+        }
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1) continue;
+        const key = line.slice(0, colonIdx).trim();
+        let value = line.slice(colonIdx + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1).replace(/\\"/g, '"');
+        }
+        if (value === "") {
+          lastArrayKey = key;
+          parsed[key] = [];
+        } else {
+          lastArrayKey = null;
+          parsed[key] = value;
+        }
+      }
+      const slug = parsed["slug"];
+      if (!slug) {
+        console.error(`  skipped ${file} (no slug field)`);
+        continue;
+      }
+      const payload = {};
+      if (parsed["what"]) payload.what = parsed["what"];
+      if (parsed["how"]) payload.how = parsed["how"];
+      if (parsed["where_files"]) payload.where_files = parsed["where_files"];
+      if (parsed["anchored_doc"]) payload.anchored_doc_path = parsed["anchored_doc"];
+      if (parsed["decisions"]) payload.decisions = parsed["decisions"];
+      if (parsed["gotchas"]) payload.gotchas = parsed["gotchas"];
+      if (parsed["ownership"]) payload.ownership = parsed["ownership"];
+      let exists = false;
+      try {
+        await api.get(`/workspaces/${workspaceSlug}/watchers/${slug}`);
+        exists = true;
+      } catch {
+        exists = false;
+      }
+      try {
+        if (exists) {
+          await api.patch(`/workspaces/${workspaceSlug}/watchers/${slug}`, payload);
+          console.log(`  \u2713 ${slug} (updated)`);
+          updated++;
+        } else {
+          const name = slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+          await api.post(`/workspaces/${workspaceSlug}/watchers`, { name, ...payload });
+          console.log(`  \u2713 ${slug} (created)`);
+          created++;
+        }
+      } catch (e) {
+        console.error(`  \u2717 ${slug}: ${formatError(e)}`);
+      }
+    }
+    if (!isJSON) {
+      console.log(`
+Done: ${created} created, ${updated} updated.`);
+    } else {
+      emitJSON2({ created, updated });
+    }
+    return;
+  }
   console.log(`Usage: driftless context <list|get|add|update|delete|search|push> [args]
 
 Run 'driftless help context' for full reference.`);
@@ -215623,8 +215908,8 @@ Run 'driftless help context' for full reference.`);
 
 // src/commands/session.ts
 init_git();
-var import_node_fs5 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
 function parseArgs2(args) {
   const flags = {};
   const positional = [];
@@ -215686,7 +215971,7 @@ async function sessionCommand(args) {
       }
       process.exit(0);
     }
-    const missingFiles = files.filter((f) => !(0, import_node_fs5.existsSync)((0, import_node_path5.resolve)(process.cwd(), f)));
+    const missingFiles = files.filter((f) => !(0, import_node_fs6.existsSync)((0, import_node_path6.resolve)(process.cwd(), f)));
     if (missingFiles.length > 0 && !isJSON) {
       console.error(`Warning: ${missingFiles.length} file(s) not found locally \u2014 matching by pattern only.`);
     }
@@ -215735,7 +216020,7 @@ async function sessionCommand(args) {
         console.log(`Session started for ${files.length} file(s):
 `);
         for (const f of files) {
-          const exists = (0, import_node_fs5.existsSync)((0, import_node_path5.resolve)(process.cwd(), f));
+          const exists = (0, import_node_fs6.existsSync)((0, import_node_path6.resolve)(process.cwd(), f));
           console.log(`  ${exists ? "\u2713" : "\u2717"} ${f}`);
         }
         if (missingFiles.length > 0) {
@@ -215804,9 +216089,9 @@ Rules that will be evaluated:`);
         console.error(`Repo '${remote.repo}' not found. Run 'driftless init' first.`);
         process.exit(1);
       }
-      const { getUncommittedDiff: getUncommittedDiff3, getStagedDiff: getStagedDiff2, getLastCommitHash: getLastCommitHash2, getAuthorName: getAuthorName2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+      const { getUncommittedDiff: getUncommittedDiff2, getStagedDiff: getStagedDiff2, getLastCommitHash: getLastCommitHash2, getAuthorName: getAuthorName2 } = await Promise.resolve().then(() => (init_git(), git_exports));
       const staged = getStagedDiff2();
-      const unstaged = getUncommittedDiff3();
+      const unstaged = getUncommittedDiff2();
       const diff = [staged, unstaged].filter(Boolean).join("\n");
       if (!diff && !isJSON) {
         console.log("No changes to scan. Session clean.");
@@ -215896,149 +216181,6 @@ Examples:
   driftless session finish         # scan + context report`);
 }
 
-// src/commands/install-skill.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path6 = require("node:path");
-var template = `# Driftless \u2014 Live Repo Context
-
-Driftless Cloud holds the team's living codebase context (topics, anchors, rules, gotchas).
-This file teaches you how to use it. Treat it as part of the toolchain, not documentation.
-
-## Agent loop
-
-### 1. Before editing \u2014 pull context
-
-If you know the topic:
-
-\`\`\`bash
-driftless context get <topic>
-\`\`\`
-
-If you don't know which topic applies, discover it:
-
-\`\`\`bash
-driftless context search "<keyword>"
-driftless context list
-\`\`\`
-
-The \`get\` response is a canonical JSON object:
-
-\`\`\`json
-{
-  "topic": "<slug>",
-  "summary": "...",
-  "description": {
-    "what": "...",
-    "how": "...",
-    "decisions": "...",
-    "gotchas": [],
-    "ownership": "..."
-  },
-  "anchors": {
-    "files": [],
-    "patterns": [],
-    "repos": [],
-    "docs": []
-  },
-  "components": [],
-  "rules": [],
-  "invariants": [],
-  "violations": [],
-  "events": [],
-  "required_checks": [],
-  "stale": { "is_stale": false, "reason": null },
-  "metadata": { "created_by": "...", "last_updated": "...", "source": "manual|auto|doc|agent" }
-}
-\`\`\`
-
-Always read:
-- \`description.what\` and \`description.how\` \u2014 what you're about to touch
-- \`description.decisions\` \u2014 why it's built this way
-- \`description.gotchas\` \u2014 known traps
-- \`anchors.docs\` \u2014 anchored team docs
-- \`stale.is_stale\` \u2014 if true, the context may be outdated; read \`stale.reason\`
-
-Note: \`rules\`, \`invariants\`, \`violations\`, \`events\`, and \`required_checks\` may be empty
-during PR 1; they get populated in subsequent releases. Other fields are authoritative.
-
-### 2. During work
-
-Respect what the topic tells you. Follow decisions and gotchas. If anchored docs contradict
-code, the docs are usually intent \u2014 verify before changing.
-
-### 3. Before finishing \u2014 scan
-
-\`\`\`bash
-driftless scan --diff
-\`\`\`
-
-This evaluates your uncommitted changes against active Cloud rules. Exit code:
-- \`0\` \u2014 clean
-- \`1\` \u2014 violations (read each \`explanation\`, fix, re-scan until clean)
-
-Do not push if scan returns violations.
-
-### 4. After learning \u2014 write context back
-
-If you discovered something durable about the codebase, write it back so the next session benefits:
-
-Update an existing topic:
-
-\`\`\`bash
-driftless context update <topic> \\
-  --gotchas "Setting X to Y breaks Z under condition W"
-\`\`\`
-
-Or add a new topic:
-
-\`\`\`bash
-driftless context add "<name>" \\
-  --what "What this piece is" \\
-  --how "How it works" \\
-  --pattern "src/path/**" \\
-  --decisions "Why built this way" \\
-  --gotchas "Known traps" \\
-  --ownership "@team"
-\`\`\`
-
-Field reference:
-- \`--what\`, \`--how\`, \`--decisions\`, \`--gotchas\`, \`--ownership\`
-- \`--pattern\` (glob) or \`--where\` (explicit path) \u2014 mutually exclusive
-- \`--file <path>\` (on \`add\`) \u2014 anchor an existing markdown doc
-
-## Output format
-
-All CLI commands output JSON by default for agent consumption. Use \`--human\` for readable text.
-
-## What Driftless is
-
-Living context infrastructure for coding agents. CLI is the daily interface; the dashboard
-is observability for humans, not where agents work.
-
-## What Driftless is not
-
-Does not modify code. Does not approve or reject PRs. Does not block merges. Is not CI.
-Is not an AI reviewer.
-
-Context delivery + structural verification only.
-`;
-function installSkillCommand() {
-  const cwd = process.cwd();
-  const agentsPath = (0, import_node_path6.resolve)(cwd, "AGENTS.md");
-  if ((0, import_node_fs6.existsSync)(agentsPath)) {
-    const existing = (0, import_node_fs6.readFileSync)(agentsPath, "utf8");
-    if (existing.includes("# Driftless")) {
-      console.log("Driftless section already present in AGENTS.md.");
-      return;
-    }
-    (0, import_node_fs6.writeFileSync)(agentsPath, existing + "\n---\n\n" + template);
-    console.log(`Appended Driftless section to ${agentsPath}`);
-  } else {
-    (0, import_node_fs6.writeFileSync)(agentsPath, template);
-    console.log(`Driftless skill installed at ${agentsPath}`);
-  }
-}
-
 // src/commands/login.ts
 var import_node_fs7 = require("node:fs");
 var import_node_path7 = require("node:path");
@@ -216256,7 +216398,7 @@ function pad2(s, n) {
 }
 
 // src/index.ts
-var VERSION = "0.1.24";
+var VERSION = "0.1.26";
 var HELP_TEXT = `Driftless CLI v${VERSION} \u2014 Living repo context for humans and coding agents
 
 Install:  npm install -g @driftless-sh/cli
@@ -216476,7 +216618,7 @@ async function main() {
       await sessionCommand(args.slice(1));
       break;
     case "install-skill":
-      installSkillCommand();
+      await installSkillCommand();
       break;
     case "login":
       loginCommand(args.slice(1));