@maycombhq/atticus 2.0.0-beta.21 → 2.0.0-beta.22

package/dist/packages/sdk/npm/index.js

@@ -1667,13 +1667,41 @@ function normalizePath(input) {
   const trimmed = input.trim();
   if (trimmed === "")
     return "";
-  const withoutQuery = trimmed.split(/[?#]/, 1)[0] ?? "";
+  const withoutQuery = stripParamConstraints(trimmed).split(/[?#]/, 1)[0] ?? "";
   const isPath = withoutQuery.startsWith("/") || withoutQuery.includes("/");
   if (!isPath)
     return withoutQuery;
   const segments = withoutQuery.split("/").filter((s) => s.length > 0).map((s) => /^(\{[^}]*\}|:[^/]+|<[^>]+>|\$\{[^}]*\})$/.test(s) ? "{}" : s);
   return "/" + segments.join("/");
 }
+function stripParamConstraints(path) {
+  let out = "";
+  let i = 0;
+  while (i < path.length) {
+    const ch = path[i];
+    if (ch !== "{") {
+      out += ch;
+      i++;
+      continue;
+    }
+    let depth = 0;
+    let j = i;
+    for (; j < path.length; j++) {
+      if (path[j] === "{")
+        depth++;
+      else if (path[j] === "}" && --depth === 0)
+        break;
+    }
+    if (j >= path.length) {
+      out += path.slice(i);
+      break;
+    }
+    const inner = path.slice(i + 1, j);
+    out += "{" + (/^[^:?=]*/.exec(inner)?.[0] ?? "") + "}";
+    i = j + 1;
+  }
+  return out;
+}
 function interfaceId(from, to, method, path) {
   const key = [from, to, (method ?? "").toUpperCase(), normalizePath(path)].join("|");
   return "if-" + createHash("sha256").update(key, "utf8").digest("hex").slice(0, 16);
@@ -1769,6 +1797,17 @@ function flowIssues(f) {
   return issues;
 }
 function parseRecord(input) {
+  const v = input?.schemaVersion;
+  if (typeof v === "number" && Number.isInteger(v) && v > SCHEMA_VERSION)
+    return {
+      ok: false,
+      issues: [
+        {
+          path: "schemaVersion",
+          message: `written by a newer Atticus (record version ${v}); install it to read this record`
+        }
+      ]
+    };
   const result = CatalogRecord.safeParse(input);
   if (!result.success) {
     return {
@@ -2771,6 +2810,27 @@ var IntegrationPattern = z11.strictObject({
   version: Semver,
   status: z11.enum(["confirmed", "to-review", "deprecated"])
 });
+function gitRefProblem(ref2) {
+  if (!ref2)
+    return "it is empty";
+  if (ref2.startsWith("-"))
+    return "it starts with -";
+  if (/[\x00-\x20\x7f]/.test(ref2))
+    return "it has a space or a control character";
+  if (/[~^:?*[\\]/.test(ref2))
+    return "it has one of ~ ^ : ? * [ \\";
+  if (ref2.includes(".."))
+    return "it has ..";
+  if (ref2.includes("@{") || ref2 === "@")
+    return "it is @ or has @{";
+  if (ref2.startsWith("/") || ref2.endsWith("/") || ref2.includes("//"))
+    return "it starts or ends with /, or has //";
+  if (ref2.endsWith("."))
+    return "it ends with .";
+  if (ref2.split("/").some((c) => c.startsWith(".") || c.endsWith(".lock")))
+    return "a part of it starts with . or ends with .lock";
+  return void 0;
+}
 var RelPath = z11.string().min(1).refine((p2) => !p2.startsWith("/") && !/^[A-Za-z]:/.test(p2) && !p2.includes("\\") && !p2.split("/").includes(".."), "a relative path inside the metarepo");
 var SourceTags = z11.strictObject({
   kinds: z11.array(RecordId).default([]),
@@ -2849,7 +2909,11 @@ var Sources = z11.strictObject({
     /** What the source is about (ADR 0083), to guide the knowledge scan and filter items. */
     tags: SourceTags.optional(),
     /** A git wiki's branch or tag; default its default branch. A name git takes as a ref, never as an option. */
-    ref: z11.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "a branch or tag name").optional(),
+    ref: z11.string().max(200).superRefine((r, ctx) => {
+      const why = gitRefProblem(r);
+      if (why)
+        ctx.addIssue({ code: "custom", message: `a branch or tag name: ${why}` });
+    }).optional(),
     /** The folder of a git wiki its pages are in; default the whole repository. */
     path: RelPath.optional(),
     /** A git wiki is cloned into local state (clone), or kept as a submodule of the metarepo under knowledge/repos/. */
@@ -2941,10 +3005,11 @@ var AdapterSettings = z11.record(z11.string(), z11.union([z11.string(), z11.numb
     }
   }
 });
-var adapter = (types, o = {}) => z11.strictObject({
-  type: z11.enum([...types, "mock", ...o.manual === false ? [] : ["manual"]]),
-  settings: AdapterSettings.default({})
-});
+var adapter = (types, o = {}) => {
+  const type = z11.enum([...types, "mock", ...o.manual === false ? [] : ["manual"]]);
+  const full = z11.strictObject({ type, settings: AdapterSettings.default({}) });
+  return z11.union([type.transform((t) => ({ type: t, settings: {} })), full]);
+};
 var BuildEngine = z11.enum(["speckit", "atticus"]);
 var Autonomy = z11.enum(["plan-only", "draft", "draft-and-pr"]);
 var RetrievalSettings = z11.strictObject({
@@ -3336,6 +3401,9 @@ var Profile = z11.strictObject({
   });
 });
 
+// packages/core/dist/metarepo.js
+var LAYOUT_PATH = Sources.shape.layout.unwrap().shape.catalog.unwrap().optional();
+
 // packages/core/dist/roles-migrate.js
 import { isMap, parseDocument } from "yaml";
 
@@ -3745,6 +3813,13 @@ var AuditFile = z17.strictObject({
   items: z17.array(AuditItem)
 });
 
+// packages/core/dist/cite.js
+var SECRET_WORDS = "(?:password|passwd|pwd|secret|token|api[-_]?key|access[-_]?key|private[-_]?key|credentials?)";
+var KEY_LITERAL = new RegExp(`((?:^|[^A-Za-z0-9_.$-])[A-Za-z0-9_.$-]*?${SECRET_WORDS}["'\`]?\\]?(?:\\s*:\\s*[A-Za-z_][\\w.<>?\\[\\]]*(?=\\s*=))?\\s*(?::=|=>|=(?!=)|:(?!:))\\s*)(["'\`])((?:(?!\\2)[^\\\\]|\\\\.)+)\\2`, "i");
+var SETTER_LITERAL = new RegExp(`(\\b(?:set|with)[A-Za-z0-9_]*?${SECRET_WORDS}\\s*\\(\\s*)(["'\`])((?:(?!\\2)[^\\\\]|\\\\.)+)\\2`, "i");
+var KEY_BARE = new RegExp(`((?:\\bexport\\s+|--|[?&;])[A-Za-z0-9_.-]*?${SECRET_WORDS}\\s*=\\s*)([^\\s&;"'\`]+)`, "gi");
+var SECRET_IDENT = new RegExp(`[A-Za-z0-9_]*${SECRET_WORDS}[A-Za-z0-9_]*`, "i");
+
 // packages/core/dist/json-schema.js
 import { z as z27 } from "zod";
 
@@ -7205,13 +7280,42 @@ var ProposePlanView = z30.object({
    */
   applyFirst: z30.array(z30.string()).optional()
 });
+var CONFIRMED_WRITES = [
+  "handoff",
+  "release-prs",
+  "merge",
+  "task-pr",
+  "digest-send",
+  "propose",
+  "step-run",
+  "ai-model",
+  "ai-test"
+];
+var ConfirmedWrite = z30.enum(CONFIRMED_WRITES);
+var Confirmation = z30.string().regex(/^[A-Za-z0-9_-]{16,128}$/, "a confirmation");
+var ConfirmationRequest = z30.strictObject({
+  write: ConfirmedWrite,
+  /** What the write is for: the change, `<change>/<task>`, the step, the scope, `me` or `model`. */
+  target: z30.string().min(1).max(400),
+  /** The page's own key, from its <meta name="atticus-page-key">; never printed. */
+  pageKey: z30.string().max(200).optional()
+});
+var ConfirmationView = z30.object({
+  confirmation: Confirmation,
+  write: ConfirmedWrite,
+  target: z30.string(),
+  expiresAt: z30.string()
+});
+var ConfirmedRequest = z30.strictObject({ confirmation: Confirmation.optional() });
 var ProposeRequest = z30.strictObject({
   scope: ProposeScope,
   /** Exactly the files the person saw listed; one that changed back since is left out. */
   files: z30.array(z30.string().min(1)).min(1),
   title: z30.string().max(200).optional(),
   /** The branch GET's plan showed, so the PR is on the branch the person saw. */
-  branch: z30.string().max(200).optional()
+  branch: z30.string().max(200).optional(),
+  /** 3.0.0 (ADR 0186): the person's confirmation from the app (`propose`, the scope). */
+  confirmation: Confirmation.optional()
 });
 var LinesView = z30.object({
   code: z30.number().int().optional(),
@@ -7446,10 +7550,15 @@ var FindingActionRequest = z30.strictObject({
 var OpenWorkspaceRequest = z30.strictObject({ repos: z30.array(RecordId).min(1) });
 var HandoffRequest = z30.strictObject({
   phase: Phase.optional(),
-  repo: z30.string().optional()
+  repo: z30.string().optional(),
+  /** 3.0.0 (ADR 0186): the person's confirmation from the app (`handoff`, the change). */
+  confirmation: Confirmation.optional()
 });
-var SyncRequest = z30.strictObject({ repo: z30.string().optional() });
-var ReleasePrsRequest = z30.strictObject({});
+var SyncRequest = z30.strictObject({
+  repo: z30.string().optional(),
+  confirmation: Confirmation.optional()
+});
+var ReleasePrsRequest = z30.strictObject({ confirmation: Confirmation.optional() });
 var TaskDoneRequest = z30.strictObject({ done: z30.boolean() });
 var CHANGE_OWNER_ROLES = [
   "product-owner",
@@ -7507,7 +7616,9 @@ var StepRunRequest = z30.strictObject({
   with: z30.string().min(1),
   inputsSha256: z30.string().regex(/^[0-9a-f]{64}$/, "the sha-256 the preview showed"),
   fillOnly: z30.boolean().optional(),
-  change: z30.string().optional()
+  change: z30.string().optional(),
+  /** 3.0.0 (ADR 0186): the person's confirmation from the app (`step-run`, the step). */
+  confirmation: Confirmation.optional()
 });
 var ArchiveRequest = z30.strictObject({ rescan: z30.boolean().optional() });
 var DraftRequestsRequest = z30.strictObject({ force: z30.boolean().optional() });
@@ -7550,7 +7661,10 @@ var SaveNotifyRequest = z30.strictObject({
   digest: z30.enum(["off", "daily", "weekly"]),
   channel: z30.string().trim().min(1).optional()
 });
-var SendDigestRequest = z30.strictObject({ send: z30.boolean().default(false) });
+var SendDigestRequest = z30.strictObject({
+  send: z30.boolean().default(false),
+  confirmation: Confirmation.optional()
+});
 var TriageDecideRequest = z30.strictObject({
   option: z30.number().int().min(1),
   reason: z30.string().trim().min(1).optional()
@@ -7586,7 +7700,8 @@ var QuestionList = z30.object({
   problems: z30.array(z30.object({ file: z30.string(), message: z30.string() })),
   /**
    * 2.51.0: every question on file by state, whatever `state` or `mine` the list asked for, so a
-   * page shows its counts from the one request.
+   * page shows its counts from the one request. With `change` they are that change's; with `role`
+   * that role's, as the list is (`byRole` stays every role's).
    */
   counts: z30.object({
     open: z30.number().int(),
@@ -8592,6 +8707,16 @@ var OPS = {
       ok: { status: 200, schema: "Health", description: "OK" }
     }
   },
+  "/api/confirmations": {
+    post: {
+      id: "confirmWrite",
+      summary: "3.0.0 (ADR 0186): the app's page asks, on the person's click, for a confirmation of one write to a shared system (a hand-off, the release PRs, a merge, a task's PR, sending the digest, Propose for review, a step run with a team's tool, where the model's key goes, a Test of uncommitted model settings). It needs the page key the server puts in the page and never prints, so the session token alone gets 403; the confirmation is for that write and target, used once, and expires after two minutes",
+      tag: "system",
+      body: ConfirmationRequest,
+      ok: { status: 201, schema: "ConfirmationView", description: "The confirmation" },
+      errors: [400, 403]
+    }
+  },
   "/api/me": {
     get: {
       id: "getMe",
@@ -8627,7 +8752,7 @@ var OPS = {
   "/api/me/digest": {
     post: {
       id: "sendDigest",
-      summary: "What waits on the person; with send, posted through the notify adapter as their approval",
+      summary: "What waits on the person; with send, posted through the notify adapter as their approval. 3.0.0 (ADR 0186): send needs the person's confirmation (`digest-send`, `me`), else 403",
       tag: "system",
       body: SendDigestRequest,
       ok: {
@@ -8635,7 +8760,7 @@ var OPS = {
         schema: { type: "object", required: ["title", "body", "lines"] },
         description: "The digest, with sent or notSent"
       },
-      errors: [400]
+      errors: [400, 403]
     }
   },
   "/api/across": {
@@ -9422,10 +9547,11 @@ var OPS = {
   "/api/workspace/sync": {
     post: {
       id: "syncWorkspace",
-      summary: "Clone or update base clones",
+      summary: "Clone or update base clones. 3.0.0 (review round 48): 409 while a sync runs on this server",
       tag: "workspace",
       body: ScanRequest.pick({ repos: true }),
-      ok: { status: 202, schema: "JobAccepted", description: "Job started" }
+      ok: { status: 202, schema: "JobAccepted", description: "Job started" },
+      errors: [409]
     }
   },
   "/api/scan": {
@@ -9441,11 +9567,11 @@ var OPS = {
   "/api/reconcile": {
     post: {
       id: "startReconcile",
-      summary: "Check a diagram against the catalog",
+      summary: "Check a diagram against the catalog. 3.0.0 (review round 48): 409 while a reconcile runs on this server",
       tag: "scans",
       body: ReconcileRequest,
       ok: { status: 202, schema: "JobAccepted", description: "Job started" },
-      errors: [404]
+      errors: [404, 409]
     }
   },
   "/api/jobs/{jobId}": {
@@ -9513,7 +9639,7 @@ var OPS = {
     },
     post: {
       id: "proposeForReview",
-      summary: "2.65.0 (ADR 0183): on the person's yes, commit exactly those files to the branch, push it and open the PR; a person merges",
+      summary: "2.65.0 (ADR 0183): on the person's yes, commit exactly those files to the branch, push it and open the PR; a person merges. 3.0.0 (ADR 0186): needs the person's confirmation (`propose`, the scope), else 403",
       tag: "workspace",
       body: ProposeRequest,
       ok: {
@@ -9522,7 +9648,7 @@ var OPS = {
         description: "Started: its job's result is the code and the lines"
       },
       // 2.68.0: 409 while another local step (Apply, Propose, Bring in) runs.
-      errors: [400, 409]
+      errors: [400, 403, 409]
     }
   },
   "/api/owner-questions": {
@@ -9604,7 +9730,7 @@ var OPS = {
   "/api/changes/{changeId}/release-prs": {
     post: {
       id: "raiseReleasePrs",
-      summary: "Raise one release PR per code repo from change/<id> into its default branch, as the signed-in person (ADR 0184)",
+      summary: "Raise one release PR per code repo from change/<id> into its default branch, as the signed-in person (ADR 0184). 3.0.0 (ADR 0186): needs the person's confirmation (`release-prs`, the change), else 403",
       tag: "changes",
       params: [p("changeId")],
       body: ReleasePrsRequest,
@@ -9613,18 +9739,18 @@ var OPS = {
         schema: "LinesView",
         description: "Raised: what each repo's release PR said"
       },
-      errors: [400, 404, 422]
+      errors: [400, 403, 404, 422]
     }
   },
   "/api/changes/{changeId}/sync": {
     post: {
       id: "syncChange",
-      summary: "Refresh the change from its hand-off PR and advance it when merged (ADR 0043)",
+      summary: "Refresh the change from its hand-off PR and advance it when merged (ADR 0043). 3.0.0 (ADR 0186): merges a ready PR only with the person's confirmation (`merge`, the change); without one it only reads, and a confirmation that isn't valid is 403",
       tag: "changes",
       params: [p("changeId")],
       body: SyncRequest,
       ok: { status: 200, schema: "ChangeDetail", description: "OK" },
-      errors: [400, 404, 422]
+      errors: [400, 403, 404, 422]
     }
   },
   "/api/changes/{changeId}/artifacts/{artifact}": {
@@ -9667,9 +9793,10 @@ var OPS = {
   "/api/changes/{changeId}/tasks/{taskId}/pr": {
     post: {
       id: "raiseTaskPr",
-      summary: "2.69.0 (sixth UX walk): on the person's yes, push a drafted task's branch and open its PR into the change branch",
+      summary: "2.69.0 (sixth UX walk): on the person's yes, push a drafted task's branch and open its PR into the change branch. 3.0.0 (ADR 0186): needs the person's confirmation (`task-pr`, `<change>/<task>`), else 403",
       tag: "changes",
       params: [p("changeId"), p("taskId")],
+      body: ConfirmedRequest,
       ok: { status: 201, schema: "Task", description: "The task, its PR raised" },
       errors: [403, 404, 409, 422]
     }
@@ -9720,7 +9847,7 @@ var OPS = {
   "/api/changes/{changeId}/handoff": {
     post: {
       id: "handOff",
-      summary: "Open the phase's hand-off PR after its gate passes",
+      summary: "Open the phase's hand-off PR after its gate passes. 3.0.0 (ADR 0186): needs the person's confirmation (`handoff`, the change), else 403",
       tag: "changes",
       params: [p("changeId")],
       body: HandoffRequest,
@@ -10223,12 +10350,12 @@ var OPS = {
     },
     post: {
       id: "runStep",
-      summary: "Run a step with a team's own tool; the shown inputs' sha-256 is the approval",
+      summary: "Run a step with a team's own tool on the shown inputs (their sha-256). 3.0.0 (ADR 0186): needs the person's confirmation (`step-run`, the step), else 403",
       tag: "release",
       params: [p("stepId")],
       body: StepRunRequest,
       ok: { status: 200, schema: { type: "object" }, description: "OK" },
-      errors: [400, 404, 422]
+      errors: [400, 403, 404, 422]
     }
   },
   "/api/release": {
@@ -10391,11 +10518,11 @@ var OPS = {
     },
     put: {
       id: "putAiSettings",
-      summary: "Write the AI settings to runtime.yaml: checked against the Runtime schema, keeping what it doesn't change; refuses anything that looks like a key. 2.84.0: takes decide (ADR 0181: links, questions, minPrecision), lifting a version 3 file to 4",
+      summary: "Write the AI settings to runtime.yaml: checked against the Runtime schema, keeping what it doesn't change; refuses anything that looks like a key. 2.84.0: takes decide (ADR 0181: links, questions, minPrecision), lifting a version 3 file to 4. 3.0.0 (ADR 0186): keyEnv is a variable starting ATTICUS_, one of the model providers' own key names (the list is in the model-providers package) or a name kept in this machine's credential store (422 otherwise); a change of the provider, keyEnv or an address needs the person's confirmation (`ai-model`, `model`) as `confirmation`, else 403",
       tag: "run",
       body: z30.record(z30.string(), z30.unknown()),
       ok: { status: 200, schema: { type: "object" }, description: "OK" },
-      errors: [409, 422]
+      errors: [403, 409, 422]
     }
   },
   "/api/component-types": {
@@ -10419,10 +10546,11 @@ var OPS = {
   "/api/settings/ai/test": {
     post: {
       id: "testAiProvider",
-      summary: "Ask the configured model provider one short question with nothing of the estate in it, and say whether it answered",
+      summary: "Ask the configured model provider one short question with nothing of the estate in it, and say whether it answered. 3.0.0 (ADR 0186): when runtime.yaml's model settings differ from the committed ones (HEAD), it needs the person's confirmation (`ai-test`, `model`), else 403",
       tag: "run",
+      body: ConfirmedRequest,
       ok: { status: 200, schema: { type: "object" }, description: "OK" },
-      errors: [409]
+      errors: [403, 409]
     }
   },
   "/api/settings/executors/check": {
@@ -10891,6 +11019,254 @@ import { isMap as isMap8, parseDocument as parseDocument8 } from "yaml";
 // packages/core/dist/runtime-migrate.js
 import { isMap as isMap9, parseDocument as parseDocument9 } from "yaml";
 
+// packages/core/dist/glob.js
+var notSlash = (c) => c !== "/";
+var anyChar = (c) => !/[\n\r\u2028\u2029]/.test(c);
+var Builder = class {
+  states = [];
+  add(s) {
+    this.states.push(s);
+    return this.states.length - 1;
+  }
+  /** `c*` looping on a test, then on to next. */
+  loop(test, next) {
+    const split = this.add({ kind: "split", outs: [] });
+    const ch = this.add({ kind: "char", test, out: split });
+    this.states[split].outs.push(ch, next);
+    return split;
+  }
+  /** `(?:.*\/)?` then next: any folders, or none. */
+  folders(next) {
+    const slash = this.add({ kind: "char", test: (c) => c === "/", out: next });
+    return this.add({ kind: "split", outs: [this.loop(anyChar, slash), next] });
+  }
+};
+function tidy(glob) {
+  return glob.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function compile(b, g, next) {
+  const pieces = [];
+  for (let i = 0; i < g.length; i++) {
+    const ch = g[i];
+    if (ch === "*") {
+      if (g[i + 1] === "*") {
+        const slash = g[i + 2] === "/";
+        pieces.push(slash ? (n) => b.folders(n) : (n) => b.loop(anyChar, n));
+        i += slash ? 2 : 1;
+      } else
+        pieces.push((n) => b.loop(notSlash, n));
+    } else if (ch === "?")
+      pieces.push((n) => b.add({ kind: "char", test: notSlash, out: n }));
+    else if (ch === "[") {
+      const end = g.indexOf("]", i + 2);
+      if (end < 0)
+        pieces.push(lit("["));
+      else {
+        const body = g.slice(i + 1, end).replace(/^!/, "^").replace(/\\/g, "\\\\");
+        const re = new RegExp(`^[${body}]$`);
+        pieces.push((n) => b.add({ kind: "char", test: (c) => re.test(c), out: n }));
+        i = end;
+      }
+    } else if (ch === "{") {
+      const end = g.indexOf("}", i);
+      if (end < 0)
+        pieces.push(lit("{"));
+      else {
+        const parts = g.slice(i + 1, end).split(",").map((p2) => {
+          let t = tidy(p2);
+          if (t.startsWith("/"))
+            t = t.slice(1);
+          return t;
+        });
+        const probe = new Builder();
+        for (const p2 of parts)
+          compile(probe, p2, probe.add({ kind: "match" }));
+        pieces.push((n) => b.add({ kind: "split", outs: parts.map((p2) => compile(b, p2, n)) }));
+        i = end;
+      }
+    } else
+      pieces.push(lit(ch));
+  }
+  let at = next;
+  for (let k = pieces.length - 1; k >= 0; k--)
+    at = pieces[k](at);
+  return at;
+  function lit(c) {
+    return (n) => b.add({ kind: "char", test: (x) => x === c, out: n });
+  }
+}
+function globMatcher(glob, anyDepth = !glob.replace(/\/$/, "").includes("/")) {
+  let g = tidy(glob);
+  if (g.startsWith("/")) {
+    g = g.slice(1);
+    anyDepth = false;
+  }
+  const b = new Builder();
+  const end = b.add({ kind: "match" });
+  let start = compile(b, g, end);
+  if (anyDepth)
+    start = b.folders(start);
+  const states = b.states;
+  const close = (set, s) => {
+    const stack = [s];
+    while (stack.length) {
+      const at = stack.pop();
+      if (set.has(at))
+        continue;
+      set.add(at);
+      const st = states[at];
+      if (st.kind === "split")
+        for (const o of st.outs)
+          stack.push(o);
+    }
+  };
+  return {
+    test(path) {
+      let live = /* @__PURE__ */ new Set();
+      close(live, start);
+      for (let i = 0; i < path.length; i++) {
+        const c = path[i];
+        const next = /* @__PURE__ */ new Set();
+        for (const s of live) {
+          const st = states[s];
+          if (st.kind === "char" && st.test(c))
+            close(next, st.out);
+        }
+        if (!next.size)
+          return false;
+        live = next;
+      }
+      return live.has(end);
+    }
+  };
+}
+
+// packages/core/dist/repo-files.js
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var LATIN1_HIGH = (
+  // windows-1252's 0x80-0x9F; the five it leaves undefined keep their C1 code point
+  "\u20AC\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\u017D\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\u017E\u0178"
+);
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function windows1252(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 8192) {
+    const chunk = bytes.subarray(i, i + 8192);
+    const codes = new Array(chunk.length);
+    for (let j = 0; j < chunk.length; j++) {
+      const b = chunk[j];
+      codes[j] = b >= 128 && b <= 159 ? LATIN1_HIGH.charCodeAt(b - 128) : b;
+    }
+    out += String.fromCharCode(...codes);
+  }
+  return out;
+}
+function utf16(bytes, bigEndian) {
+  const n = bytes.length - bytes.length % 2;
+  const b = Buffer.from(bytes.buffer, bytes.byteOffset, n);
+  if (!bigEndian)
+    return b.toString("utf16le");
+  const swapped = Buffer.from(b);
+  swapped.swap16();
+  return swapped.toString("utf16le");
+}
+function decodeText(bytes) {
+  if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254)
+    return utf16(bytes.subarray(2), false);
+  if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255)
+    return utf16(bytes.subarray(2), true);
+  const body = bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? bytes.subarray(3) : bytes;
+  try {
+    return utf8.decode(body);
+  } catch {
+    return windows1252(body);
+  }
+}
+function ignoreRules(text3, base) {
+  const out = [];
+  for (let line of text3.split(/\r?\n/)) {
+    line = line.replace(/(?<!\\)\s+$/, "");
+    if (!line || line.startsWith("#"))
+      continue;
+    let negate = false;
+    if (line.startsWith("!")) {
+      negate = true;
+      line = line.slice(1);
+    } else if (line.startsWith("\\!") || line.startsWith("\\#"))
+      line = line.slice(1);
+    const dirOnly = line.endsWith("/");
+    if (dirOnly)
+      line = line.slice(0, -1);
+    if (!line)
+      continue;
+    const anchored = line.includes("/");
+    try {
+      out.push({ base, re: globMatcher(line.replace(/^\//, ""), !anchored), negate, dirOnly });
+    } catch {
+    }
+  }
+  return out;
+}
+function ignoredBy(rules, path, isDir) {
+  let out = false;
+  for (const r of rules) {
+    if (r.dirOnly && !isDir)
+      continue;
+    if (r.base && !path.startsWith(`${r.base}/`))
+      continue;
+    const rel = r.base ? path.slice(r.base.length + 1) : path;
+    if (r.re.test(rel))
+      out = !r.negate;
+  }
+  return out;
+}
+var byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+function folder(entries, rel, inherited, gitignore) {
+  const rules = gitignore === void 0 ? inherited : [...inherited, ...ignoreRules(gitignore, rel)];
+  const names = entries.map((e) => e.name);
+  const kept = entries.filter((e) => !e.isSymbolicLink() && e.name !== ".git").sort(byName).map((e) => ({ e, path: rel ? `${rel}/${e.name}` : e.name }));
+  return { rules, names, kept };
+}
+var hasGitignore = (entries) => entries.some((e) => e.name === ".gitignore" && e.isFile());
+async function walkRepo(root, visit, o = {}) {
+  const max = o.max ?? Number.POSITIVE_INFINITY;
+  let files = 0;
+  let cut = false;
+  const go = async (rel, above, inherited) => {
+    const dir = rel ? join(root, ...rel.split("/")) : root;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return true;
+    }
+    const text3 = hasGitignore(entries) ? await readFile(join(dir, ".gitignore")).then(decodeText, () => void 0) : void 0;
+    const { rules, names, kept } = folder(entries, rel, inherited, text3);
+    for (const { e, path } of kept) {
+      if (e.isDirectory()) {
+        if (ignoredBy(rules, path, true) || o.skipFolder?.(above, e.name, names))
+          continue;
+        if (!await go(path, [...above, e.name], rules))
+          return false;
+      } else if (e.isFile()) {
+        if (ignoredBy(rules, path, false))
+          continue;
+        if (files >= max) {
+          cut = true;
+          return false;
+        }
+        files++;
+        if (await visit(path) === false)
+          return false;
+      }
+    }
+    return true;
+  };
+  await go("", [], []);
+  return { files, cut };
+}
+
 // packages/core/dist/log.js
 var LOG_MAX_BYTES = 5 * 1024 * 1024;
 
@@ -10918,7 +11294,8 @@ var BatchLink = z31.strictObject({
 var BatchQuestion = z31.strictObject({
   kind: z31.literal("question"),
   id: QuestionId,
-  before: QuestionAnswer.optional()
+  before: QuestionAnswer.optional(),
+  proposal: z31.string().min(1).max(65536).optional()
 });
 var BatchItem = z31.discriminatedUnion("kind", [BatchLink, BatchQuestion]);
 var DecisionBatch = z31.strictObject({
@@ -11354,8 +11731,20 @@ function globToRegExp(glob) {
 }
 
 // packages/sdk/dist/fs-repo.js
-import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
-import { join, relative, resolve, sep } from "node:path";
+import { lstat, readFile as readFile2, realpath, stat } from "node:fs/promises";
+import { join as join2, resolve, sep } from "node:path";
+
+// packages/sdk/dist/listing.js
+var LISTING = /* @__PURE__ */ Symbol.for("@maycombhq/sdk.listing");
+function listingOf(repo) {
+  const v = repo[LISTING];
+  return typeof v === "string" ? v : "";
+}
+function setListing(repo, listing) {
+  Object.defineProperty(repo, LISTING, { value: listing, enumerable: false, configurable: true });
+}
+
+// packages/sdk/dist/fs-repo.js
 var DEFAULT_IGNORES = [
   ".git",
   "node_modules",
@@ -11388,24 +11777,12 @@ function fsRepo(name, dir, commit, options = {}) {
   let cache;
   const sizes = /* @__PURE__ */ new Map();
   const skipped = /* @__PURE__ */ new Map();
-  async function walk(abs, out) {
-    const entries = await readdir(abs, { withFileTypes: true });
-    for (const e of entries) {
-      if (e.isSymbolicLink())
-        continue;
-      const full = join(abs, e.name);
-      if (e.isDirectory()) {
-        if (!ignore.has(e.name))
-          await walk(full, out);
-      } else if (e.isFile()) {
-        out.push(relative(root, full).split(sep).join("/"));
-      }
-    }
-  }
   async function allFiles() {
     if (!cache) {
       const out = [];
-      await walk(root, out);
+      await walkRepo(root, async (p2) => void out.push(p2), {
+        skipFolder: (_above, name2) => ignore.has(name2)
+      });
       cache = out.sort();
     }
     return cache;
@@ -11414,7 +11791,7 @@ function fsRepo(name, dir, commit, options = {}) {
     if (path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.includes("\\") || path.split("/").includes("..")) {
       throw new RepoReadError(`path must be repo-relative with forward slashes: ${path}`, path);
     }
-    const abs = join(root, ...path.split("/"));
+    const abs = join2(root, ...path.split("/"));
     const info = await lstat(abs).catch(() => void 0);
     if (info?.isSymbolicLink())
       throw new RepoReadError(`symbolic links are not read: ${path}`, path);
@@ -11429,7 +11806,7 @@ function fsRepo(name, dir, commit, options = {}) {
       throw new RepoReadError(`file is larger than ${maxBytes} bytes: ${path}`, path);
     return abs;
   }
-  return {
+  const handle = {
     name,
     commit,
     async *listFiles(globs) {
@@ -11438,7 +11815,7 @@ function fsRepo(name, dir, commit, options = {}) {
         if (!matchers.some((m) => m.test(p2)))
           continue;
         if (!sizes.has(p2))
-          sizes.set(p2, (await stat(join(root, ...p2.split("/"))).catch(() => void 0))?.size ?? 0);
+          sizes.set(p2, (await stat(join2(root, ...p2.split("/"))).catch(() => void 0))?.size ?? 0);
         const bytes = sizes.get(p2);
         if (bytes > maxBytes) {
           skipped.set(p2, bytes);
@@ -11452,16 +11829,17 @@ function fsRepo(name, dir, commit, options = {}) {
       return [...skipped].sort(([a], [b]) => a < b ? -1 : 1).map(([path, bytes]) => ({ path, bytes }));
     },
     async readText(path) {
-      const text3 = await readFile(await safePath(path), "utf8");
-      return text3.charCodeAt(0) === 65279 ? text3.slice(1) : text3;
+      return decodeText(await readFile2(await safePath(path)));
     }
   };
+  setListing(handle, JSON.stringify({ ignore: [...ignore].sort(), maxFileBytes: maxBytes, gitignore: true }));
+  return handle;
 }
 
 // packages/sdk/dist/cache.js
 import { createHash as createHash3 } from "node:crypto";
-import { mkdir, readdir as readdir2, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdir, readdir as readdir2, readFile as readFile3, rename, rm, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
 var sha256 = (s) => createHash3("sha256").update(s).digest("hex");
 function cacheKeyHash(key) {
   return sha256(JSON.stringify([
@@ -11500,7 +11878,7 @@ function fsScanCache(dir) {
     const h = cacheKeyHash(key);
     return {
       h,
-      path: join2(dir, key.repo, key.commit, `${key.extractor}@${key.version}.${h.slice(0, 16)}.json`)
+      path: join3(dir, key.repo, key.commit, `${key.extractor}@${key.version}.${h.slice(0, 16)}.json`)
     };
   };
   return {
@@ -11508,7 +11886,7 @@ function fsScanCache(dir) {
       const { h, path } = fileFor(key);
       let file;
       try {
-        file = JSON.parse(await readFile2(path, "utf8"));
+        file = JSON.parse(await readFile3(path, "utf8"));
       } catch {
         return void 0;
       }
@@ -11534,7 +11912,7 @@ function fsScanCache(dir) {
         checksum: sha256(JSON.stringify(value)),
         value
       };
-      await mkdir(join2(path, ".."), { recursive: true });
+      await mkdir(join3(path, ".."), { recursive: true });
       const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
       await writeFile(tmp, JSON.stringify(file), "utf8");
       await rename(tmp, path);
@@ -11546,13 +11924,13 @@ function fsScanCache(dir) {
       let removed = 0;
       let commits;
       try {
-        commits = await readdir2(join2(dir, repo));
+        commits = await readdir2(join3(dir, repo));
       } catch {
         return 0;
       }
       for (const c of commits) {
         if (!keep.has(c)) {
-          await rm(join2(dir, repo, c), { recursive: true, force: true });
+          await rm(join3(dir, repo, c), { recursive: true, force: true });
           removed++;
         }
       }
@@ -11657,7 +12035,10 @@ async function scanWith(options) {
         options.configFor?.(extractor) ?? "",
         JSON.stringify(options.repoInfo ?? {}),
         // A changed framework model means a different reading of the same code.
-        options.frameworks?.length ? JSON.stringify(options.frameworks) : ""
+        options.frameworks?.length ? JSON.stringify(options.frameworks) : "",
+        // Review round 49: the same commit listed another way (scan-settings exclusions, the
+        // folders left out, the size limit) gives the extractor other files.
+        listingOf(repo)
       ].join("|")
     };
     try {
@@ -11746,8 +12127,8 @@ async function scanWith(options) {
 
 // packages/sdk/dist/sandbox.js
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 import { Worker } from "node:worker_threads";
 var PLUGIN_EXTRACTOR_PREFIX = "plugin-";
 var MAX_RECORDS = 1e5;
@@ -11759,7 +12140,7 @@ async function readPinnedEntry(dir, manifest) {
     return { ok: false, message: "isn't pinned: run atticus plugin pin once it is reviewed" };
   let source;
   try {
-    source = await readFile3(join3(dir, ...manifest.entry.split("/")), "utf8");
+    source = await readFile4(join4(dir, ...manifest.entry.split("/")), "utf8");
   } catch (e) {
     return { ok: false, message: `can't read ${manifest.entry}: ${e.message}` };
   }