litmus-cli 1.4.39 → 1.4.41

package/dist/lib/hook-logger.cjs

@@ -465,6 +465,96 @@ function versionHeader(config) {
     : {}
 }
 
+// ── Session over (ENG-2768) ──────────────────────────────────────
+// Only `litmus submit` releases the hooks and the registry. A session that
+// ends any other way (web submit, deadline, the company ending it) leaves the
+// hooks live, and the walk-up above finds the folder's config whatever the
+// registry says, so every AI turn in an ended assessment folder kept sending
+// the candidate's prompt and reply to a server that answers `400 Session over`
+// every time: 12,229 of them over three days in production.
+//
+// So the refusal is remembered in the folder. The first refusal writes
+// `.litmus/session-over`, and every later invocation that resolves to that
+// folder stops before it records, appends, uploads or revives anything. The
+// watcher writes the same marker when IT is told the session is over (see
+// watcher.ts), which usually comes first.
+//
+// Only a refusal that can never turn into an acceptance counts: "Session over"
+// (which `/cli/activity` also returns for a token that matches no candidate,
+// ENG-2749) and "Invalid token" (its older spelling there, and other routes').
+// A 5xx, a timeout or a 429 is transient and must never silence capture of a
+// live session.
+//
+// The marker names the token it was written for, as a hash. A folder re-used
+// by a later `litmus init` carries a new token, and the old marker does not
+// silence it. A marker that names no token (unreadable, or hand-made) still
+// silences: it can only ever stop capture, never start it.
+//
+// The same hash is also written as an empty file under
+// ~/.litmus/sessions-over/, because the folder may not be writable, and a
+// folder we could not mark would otherwise keep uploading for as long as
+// another assessment keeps the user-scope hooks installed. Either copy is
+// enough.
+const SESSION_OVER_MARKER = "session-over"
+const SESSIONS_OVER_DIR = path.join(os.homedir() || os.tmpdir(), ".litmus", "sessions-over")
+const MAX_REFUSAL_BODY_BYTES = 16 * 1024
+const FINAL_REFUSAL_CODES = new Set(["session over", "invalid token"])
+
+function isFinalRefusal(status, rawBody) {
+  if (status < 400 || status >= 500 || status === 429) return false
+  let body
+  try { body = JSON.parse(rawBody) } catch { return false }
+  const detail = body && body.detail
+  const code = typeof detail === "string"
+    ? detail
+    : detail && typeof detail === "object" && typeof detail.error === "string" ? detail.error : null
+  return typeof code === "string" && FINAL_REFUSAL_CODES.has(code.trim().toLowerCase())
+}
+
+function tokenDigest(token) {
+  return typeof token === "string" && token
+    ? crypto.createHash("sha256").update(token).digest("hex")
+    : null
+}
+
+function writeSessionOverMarker(litmusDir, config, reason) {
+  const digest = tokenDigest(config && config.token)
+  try {
+    fs.writeFileSync(path.join(litmusDir, SESSION_OVER_MARKER), JSON.stringify({
+      reason,
+      at: new Date().toISOString(),
+      tokenSha256: digest,
+    }) + "\n")
+  } catch { /* unwritable folder; the home copy below still counts */ }
+  if (!digest) return
+  try {
+    fs.mkdirSync(SESSIONS_OVER_DIR, { recursive: true })
+    fs.writeFileSync(path.join(SESSIONS_OVER_DIR, digest), "")
+  } catch { /* best effort; the next refusal tries again */ }
+}
+
+function sessionOverMarked(litmusDir) {
+  const current = tokenDigest((readConfig(litmusDir) || {}).token)
+  if (current) {
+    try {
+      if (fs.statSync(path.join(SESSIONS_OVER_DIR, current)).isFile()) return true
+    } catch { /* not recorded at home */ }
+  }
+  let raw
+  try {
+    raw = fs.readFileSync(path.join(litmusDir, SESSION_OVER_MARKER), "utf8")
+  } catch {
+    return false
+  }
+  let marked = null
+  try {
+    const parsed = JSON.parse(raw)
+    if (parsed && typeof parsed.tokenSha256 === "string" && parsed.tokenSha256) marked = parsed.tokenSha256
+  } catch { /* names no token */ }
+  if (!marked) return true
+  return !current || current === marked
+}
+
 /**
  * POST the event to /cli/activity and WAIT for it to complete, bounded.
  *
@@ -474,16 +564,17 @@ function versionHeader(config) {
  * the in-zip activity.jsonl) kept working, so nothing surfaced it.
  *
  * Resolves rather than rejects on every failure path: a telemetry upload must
- * never fail a candidate's prompt. Both timers are cleared on settle.
+ * never fail a candidate's prompt. Both timers are cleared on settle. Resolves
+ * `{ sessionOver }`, true only when the server refused the token for good.
  */
 function uploadEvent(config, event) {
-  if (!config || !config.token || !config.backendUrl) return Promise.resolve()
+  if (!config || !config.token || !config.backendUrl) return Promise.resolve({ sessionOver: false })
 
   let url
   try {
     url = new URL(`${config.backendUrl}/cli/activity`)
   } catch {
-    return Promise.resolve() // malformed backendUrl — nothing to do
+    return Promise.resolve({ sessionOver: false }) // malformed backendUrl — nothing to do
   }
 
   const body = JSON.stringify({ events: [event] })
@@ -492,11 +583,12 @@ function uploadEvent(config, event) {
   return new Promise((resolve) => {
     let settled = false
     let guard = null
+    let sessionOver = false
     const done = () => {
       if (settled) return
       settled = true
       if (guard) clearTimeout(guard)
-      resolve()
+      resolve({ sessionOver })
     }
 
     const req = reqFn(url, {
@@ -518,7 +610,24 @@ function uploadEvent(config, event) {
       timeout: UPLOAD_TIMEOUT_MS,
     })
     // Drain the response so the socket can close and the event loop empty.
-    req.on("response", (res) => { res.resume(); res.on("end", done); res.on("error", done) })
+    // A 4xx body is kept (capped) because it is the only place the server says
+    // the assessment is over for good (ENG-2768, see isFinalRefusal).
+    req.on("response", (res) => {
+      const status = res.statusCode || 0
+      const chunks = []
+      let kept = 0
+      res.on("data", (chunk) => {
+        if (status >= 400 && status < 500 && kept < MAX_REFUSAL_BODY_BYTES) {
+          chunks.push(chunk)
+          kept += chunk.length
+        }
+      })
+      res.on("end", () => {
+        if (chunks.length) sessionOver = isFinalRefusal(status, Buffer.concat(chunks).toString("utf8"))
+        done()
+      })
+      res.on("error", done)
+    })
     req.on("error", done)        // network down, DNS, refused, destroyed
     req.on("timeout", () => { req.destroy(); done() })
     // Backstop in case none of the above fires (a socket wedged before connect).
@@ -919,7 +1028,7 @@ function parseClaudeTranscript(raw) {
     if (entry.type !== "assistant" || !Array.isArray(content)) continue
     for (const block of content) {
       if (block && block.type === "text" && typeof block.text === "string" && block.text) {
-        collected.push(block.text)
+        collected.push({ id: typeof entry.uuid === "string" ? entry.uuid : null, text: block.text })
       }
     }
     // An assistant entry whose last block is tool_use is mid-turn; prose means
@@ -928,7 +1037,8 @@ function parseClaudeTranscript(raw) {
     tail = lastBlock && lastBlock.type === "tool_use" ? "tool" : "text"
   }
   return {
-    text: collected.length ? collected.join("\n\n") : null,
+    text: collected.length ? collected.map((b) => b.text).join("\n\n") : null,
+    blocks: collected,
     tailComplete: tail === "text",
   }
 }
@@ -986,8 +1096,13 @@ function readSettledTranscript(transcriptPath, parse) {
   }
 }
 
+// The whole parse, not just its text: `blocks` carries each block's entry id,
+// which is what lets a later Stop send only what this one did not (ENG-2793).
 function readClaudeTranscriptResponse(transcriptPath) {
-  return readSettledTranscript(transcriptPath, raw => parseClaudeTranscript(raw).text)
+  return readSettledTranscript(transcriptPath, (raw) => {
+    const parsed = parseClaudeTranscript(raw)
+    return parsed.text ? parsed : null
+  })
 }
 
 /**
@@ -1037,12 +1152,13 @@ function parseCopilotTranscript(raw) {
     }
     if (entry.type === "assistant.message" && entry.data
       && typeof entry.data.content === "string" && entry.data.content) {
-      collected.push(entry.data.content)
+      collected.push({ id: typeof entry.id === "string" ? entry.id : null, text: entry.data.content })
       tail = "text"
     }
   }
   return {
-    text: collected.length ? collected.join("\n\n") : null,
+    text: collected.length ? collected.map((b) => b.text).join("\n\n") : null,
+    blocks: collected,
     tailComplete: tail === "text",
   }
 }
@@ -1051,7 +1167,10 @@ function readCopilotTranscriptResponse(transcriptPath) {
   // VS Code flushes before running the hook but bounds that flush at 500ms,
   // and the Copilot CLI's flush behavior is undocumented — so wait for
   // quiescence like the others.
-  return readSettledTranscript(transcriptPath, raw => parseCopilotTranscript(raw).text)
+  return readSettledTranscript(transcriptPath, (raw) => {
+    const parsed = parseCopilotTranscript(raw)
+    return parsed.text ? parsed : null
+  })
 }
 
 /**
@@ -1175,8 +1294,10 @@ function extractResponse(data, toolName) {
       // Claude Code Stop payload: { session_id, transcript_path, cwd,
       // hook_event_name, stop_hook_active }. The response text is not in the
       // payload — read it from the transcript.
+      const parsed = readClaudeTranscriptResponse(data.transcript_path)
       return {
-        text: readClaudeTranscriptResponse(data.transcript_path),
+        text: parsed ? parsed.text : null,
+        blocks: parsed ? parsed.blocks : null,
         sessionId: data.session_id || null,
       }
     }
@@ -1220,8 +1341,10 @@ function extractResponse(data, toolName) {
       // Copilot Stop (both surfaces, via the PascalCase config spelling):
       // { hook_event_name: "Stop", session_id, transcript_path, ... }. The
       // response is in the transcript, not the payload.
+      const parsed = readCopilotTranscriptResponse(data.transcript_path || data.transcriptPath)
       return {
-        text: readCopilotTranscriptResponse(data.transcript_path || data.transcriptPath),
+        text: parsed ? parsed.text : null,
+        blocks: parsed ? parsed.blocks : null,
         sessionId: data.session_id || data.sessionId || null,
       }
     }
@@ -1377,6 +1500,51 @@ function currentTurnRecord(sessionId) {
   }
 }
 
+// ── What a Stop has already sent (ENG-2793) ──────────────────────────
+// The Claude and Copilot readers collect every assistant message since the last
+// genuine user entry in the transcript. A Stop that fires again before one is
+// written collects the previous reply as well, and the report showed it twice:
+// measured on production, 258 hook replies began with the previous reply and a
+// blank line. So each Stop records the transcript entry its reply ended on, and
+// the next one sends only the blocks written after it. Kept beside the turn file
+// rather than in it, because `startTurn` rewrites that one on every prompt and a
+// re-send crosses prompts as often as not. A transcript without entry ids
+// records nothing and sends what it collected, as before.
+
+function repliedFile(sessionId) {
+  return turnFile(sessionId).replace(/\.json$/, ".replied.json")
+}
+
+/** The entry id the session's last captured reply ended on, if any. */
+function lastRepliedEntry(sessionId) {
+  if (!sessionId) return null
+  try {
+    const data = JSON.parse(fs.readFileSync(repliedFile(sessionId), "utf8"))
+    return typeof data.entryId === "string" ? data.entryId : null
+  } catch {
+    return null
+  }
+}
+
+function recordRepliedEntry(sessionId, entryId) {
+  if (!sessionId || !entryId) return
+  try {
+    fs.mkdirSync(TURNS_DIR, { recursive: true })
+    fs.writeFileSync(repliedFile(sessionId), JSON.stringify({ entryId, ts: Date.now() }))
+  } catch {
+    // Unwritable: the next reply may repeat this one, which the report folds.
+  }
+}
+
+/** The blocks written after `entryId`. All of them when it is not among them,
+ *  because then a genuine prompt has started collection again since. */
+function unsentBlocks(blocks, entryId) {
+  if (!entryId) return blocks
+  let at = -1
+  blocks.forEach((b, i) => { if (b.id === entryId) at = i })
+  return at < 0 ? blocks : blocks.slice(at + 1)
+}
+
 // ── Cursor's agent edits (ENG-2344) ──────────────────────────────────
 // Composer routes its model traffic to Cursor's own backend, so neither the
 // gateway nor the in-container MITM ever sees the tool call that writes a file
@@ -1716,6 +1884,15 @@ async function main() {
   try { parsed = JSON.parse(raw) } catch { /* extractPrompt reports the failure */ }
   const cursorShaped = isCursorPayload(parsed)
 
+  // ENG-2768: an assessment whose session is over records nothing more. Asked
+  // here, before any transcript read, against the same placement the event
+  // would get (the payload's workspace roots are the only roots any tool's
+  // extractor reports), and asked again below once the event's own placement
+  // is known.
+  const earlyRoots = parsed && Array.isArray(parsed.workspace_roots) ? parsed.workspace_roots : []
+  const earlyLitmusDir = resolveAssessmentDir(parsed, earlyRoots)
+  if (earlyLitmusDir && sessionOverMarked(earlyLitmusDir)) return
+
   // ENG-2477: a capture SELF-TEST probe. `litmus init` (and `litmus doctor`)
   // run this script the way the tool would — the tool's own payload shape, on
   // stdin, through the command string in the tool's own config file — plus
@@ -1767,7 +1944,7 @@ async function main() {
   if (effectiveTool === "cursor" && parsed && parsed.hook_event_name === CURSOR_EDIT_EVENT) {
     const roots = Array.isArray(parsed.workspace_roots) ? parsed.workspace_roots : []
     const editLitmusDir = resolveAssessmentDir(parsed, roots)
-    if (!editLitmusDir) return
+    if (!editLitmusDir || sessionOverMarked(editLitmusDir)) return
     recordCursorFileEdit(parsed, parsed.session_id || parsed.conversation_id || null,
                          path.dirname(editLitmusDir))
     return
@@ -1777,12 +1954,20 @@ async function main() {
   let sessionId = null
   let workspaceRoots = []
   let responseMeta = null
+  // ENG-2793: the entry this reply ends on, recorded once the reply is written.
+  let repliedEntry = null
   if (responseEvent) {
     const extracted = extractResponse(parsed, effectiveTool)
     content = extracted.text
     sessionId = extracted.sessionId
     workspaceRoots = extracted.workspaceRoots || []
     responseMeta = extracted.meta || null
+    const blocks = extracted.blocks
+    if (blocks && blocks.length && sessionId && !selftestNonce) {
+      const unsent = unsentBlocks(blocks, lastRepliedEntry(sessionId))
+      content = unsent.length ? unsent.map((b) => b.text).join("\n\n") : null
+      repliedEntry = blocks[blocks.length - 1].id
+    }
   } else {
     const extracted = extractPrompt(raw, effectiveTool)
     content = extracted.prompt
@@ -1797,6 +1982,7 @@ async function main() {
 
   const litmusDir = resolveAssessmentDir(parsed, workspaceRoots)
   if (!litmusDir) return
+  if (litmusDir !== earlyLitmusDir && sessionOverMarked(litmusDir)) return
 
   // Claim as LATE as possible — only once we know we have content and somewhere
   // to put it. Claiming earlier would let an invocation that then bails (no
@@ -1907,6 +2093,10 @@ async function main() {
   } catch {
     // Non-critical
   }
+  // ENG-2793: the next Stop starts after this reply only once a copy of it is
+  // on disk. The drain and the upload report no outcome, so a reply whose append
+  // failed is sent again by the next Stop, and the report folds the repeat.
+  if (repliedEntry && logged) recordRepliedEntry(sessionId, repliedEntry)
   // ENG-2344: the edits this reply carries leave the ledger only now that the
   // reply is on disk. An append that failed hands them back for the next reply.
   if (editLedger) {
@@ -1922,7 +2112,15 @@ async function main() {
 
   // 2. Upload to the server. Awaited, bounded — see uploadEvent.
   const config = readConfig(litmusDir)
-  await uploadEvent(config, event)
+  const upload = await uploadEvent(config, event)
+
+  // ENG-2768: the server says this token will never be accepted again. Mark
+  // the folder so the next turn stops at the top of main(), and skip the
+  // revival below: there is no session left for a watcher to serve.
+  if (upload.sessionOver) {
+    writeSessionOverMarker(litmusDir, config, "server refused the token")
+    return
+  }
 
   // 3. Revive a dead watcher (ENG-1491). Strictly after the capture/upload
   // work — this is a courtesy, and it must never cost the prompt anything.
@@ -1937,6 +2135,9 @@ async function main() {
 // Exported for unit tests only; every hook invocation runs this file directly.
 module.exports = {
   watcherPresumedDead,
+  isFinalRefusal,
+  sessionOverMarked,
+  SESSION_OVER_MARKER,
   reviveThrottleAllows,
   buildDrainFrame,
   trimEventToBytes,

package/dist/lib/session-over.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ENG-2768: the "this session is over" marker the hook logger reads at the top
+ * of every invocation. Kept in step with `writeSessionOverMarker` and
+ * `sessionOverMarked` in hook-logger.cjs (that file is standalone CommonJS and
+ * cannot import this one): same names, same JSON shape.
+ *
+ * Two copies, either one enough. `.litmus/session-over` names the token as a
+ * sha256 hash, so a later `litmus init` into the same folder, which carries a
+ * new token, is not silenced by it. `~/.litmus/sessions-over/<hash>` is the
+ * same fact recorded outside the folder, for a folder that cannot be written.
+ */
+export declare const SESSION_OVER_MARKER = "session-over";
+export declare function sessionsOverDir(): string;
+export declare function writeSessionOverMarker(projectDir: string, token: string | undefined, reason: string): boolean;
+/** Has the session this folder's config belongs to been marked over? */
+export declare function sessionOverMarked(projectDir: string): boolean;
+/**
+ * What the watcher does with its own AI capture when the server says the
+ * session is over. The marker silences the hook logger in this folder even
+ * while another assessment keeps the user-scope hooks installed; the release
+ * drops the registry entry, the folder's own hooks and trust entries, and the
+ * user-scope hooks once no assessment is left. Only `litmus submit` used to do
+ * the release, so a session that ended any other way kept a live hook.
+ *
+ * Run by the watcher because it is alive exactly when the session ends, so no
+ * hook writer races it (the ENG-1289 concurrency problem). Marker first: it
+ * alone already stops capture, so a release that throws halfway loses nothing.
+ * The marker also keeps startTracker from bringing a watcher back here, whose
+ * hook self-heal would otherwise reinstall everything this just released.
+ */
+export declare function retireAiCaptureForEndedSession(projectDir: string, token: string | undefined): void;
+//# sourceMappingURL=session-over.d.ts.map

package/dist/lib/session-over.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-over.d.ts","sourceRoot":"","sources":["../../src/lib/session-over.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,iBAAiB,CAAA;AAEjD,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAMD,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAmB7G;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAuB7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAGlG"}

package/dist/lib/session-over.js

@@ -0,0 +1,99 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+import { createHash } from "crypto";
+import { releaseAiTrackingForAssessment } from "./ai-tracking.js";
+/**
+ * ENG-2768: the "this session is over" marker the hook logger reads at the top
+ * of every invocation. Kept in step with `writeSessionOverMarker` and
+ * `sessionOverMarked` in hook-logger.cjs (that file is standalone CommonJS and
+ * cannot import this one): same names, same JSON shape.
+ *
+ * Two copies, either one enough. `.litmus/session-over` names the token as a
+ * sha256 hash, so a later `litmus init` into the same folder, which carries a
+ * new token, is not silenced by it. `~/.litmus/sessions-over/<hash>` is the
+ * same fact recorded outside the folder, for a folder that cannot be written.
+ */
+export const SESSION_OVER_MARKER = "session-over";
+export function sessionsOverDir() {
+    return path.join(os.homedir() || os.tmpdir(), ".litmus", "sessions-over");
+}
+function tokenDigest(token) {
+    return typeof token === "string" && token ? createHash("sha256").update(token).digest("hex") : null;
+}
+export function writeSessionOverMarker(projectDir, token, reason) {
+    const digest = tokenDigest(token);
+    let written = false;
+    try {
+        writeFileSync(path.join(projectDir, ".litmus", SESSION_OVER_MARKER), JSON.stringify({
+            reason,
+            at: new Date().toISOString(),
+            tokenSha256: digest,
+        }) + "\n");
+        written = true;
+    }
+    catch { /* unwritable folder; the home copy below still counts */ }
+    if (digest) {
+        try {
+            mkdirSync(sessionsOverDir(), { recursive: true });
+            writeFileSync(path.join(sessionsOverDir(), digest), "");
+            written = true;
+        }
+        catch { /* best effort */ }
+    }
+    return written;
+}
+/** Has the session this folder's config belongs to been marked over? */
+export function sessionOverMarked(projectDir) {
+    let current = null;
+    try {
+        current = tokenDigest(JSON.parse(readFileSync(path.join(projectDir, ".litmus", "config.json"), "utf8")).token);
+    }
+    catch { /* no readable config */ }
+    if (current) {
+        try {
+            if (statSync(path.join(sessionsOverDir(), current)).isFile())
+                return true;
+        }
+        catch { /* not recorded at home */ }
+    }
+    let raw;
+    try {
+        raw = readFileSync(path.join(projectDir, ".litmus", SESSION_OVER_MARKER), "utf8");
+    }
+    catch {
+        return false;
+    }
+    let marked = null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.tokenSha256 === "string" && parsed.tokenSha256)
+            marked = parsed.tokenSha256;
+    }
+    catch { /* names no token */ }
+    if (!marked)
+        return true;
+    return !current || current === marked;
+}
+/**
+ * What the watcher does with its own AI capture when the server says the
+ * session is over. The marker silences the hook logger in this folder even
+ * while another assessment keeps the user-scope hooks installed; the release
+ * drops the registry entry, the folder's own hooks and trust entries, and the
+ * user-scope hooks once no assessment is left. Only `litmus submit` used to do
+ * the release, so a session that ended any other way kept a live hook.
+ *
+ * Run by the watcher because it is alive exactly when the session ends, so no
+ * hook writer races it (the ENG-1289 concurrency problem). Marker first: it
+ * alone already stops capture, so a release that throws halfway loses nothing.
+ * The marker also keeps startTracker from bringing a watcher back here, whose
+ * hook self-heal would otherwise reinstall everything this just released.
+ */
+export function retireAiCaptureForEndedSession(projectDir, token) {
+    writeSessionOverMarker(projectDir, token, "watcher: server signaled session over");
+    try {
+        releaseAiTrackingForAssessment(projectDir);
+    }
+    catch { /* best effort */ }
+}
+//# sourceMappingURL=session-over.js.map

package/dist/lib/session-over.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-over.js","sourceRoot":"","sources":["../../src/lib/session-over.ts"],"names":[],"mappings":"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"}

package/dist/lib/skill-import.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ENG-2814 — find the candidate's own AI tool skills on THIS machine, for `litmus
+ * connect` to offer to import into their workspace.
+ *
+ * Runs on the laptop because that is the only place the skills are: the workspace
+ * cannot see the candidate's home. The upload goes to the same `/workspace/skills`
+ * routes the assessment page's Import skills dialog uses, and NOTHING about which
+ * files are skills is decided here: `POST /workspace/skills/plan` runs the upload's
+ * own parser over the paths and SKILL.md heads and answers with the files to send
+ * (`backend/services/candidate_skills.py`). One parser cannot disagree with itself.
+ *
+ * Every folder an AI tool reads Agent Skills (`<name>/SKILL.md`) from is looked in.
+ * A folder that does not exist costs nothing; a skill found in two of them (a
+ * `.claude/skills` copy of an `.agents/skills` one, say) is imported once, and the
+ * server reports the other as a duplicate.
+ */
+export declare const SKILL_SOURCES: ReadonlyArray<{
+    dir: string;
+    tools: string;
+}>;
+export declare const PLAN_HEAD_CHARS: number;
+export interface LocalSkillFile {
+    /** Sent to the server. The source folder without its dot (`claude/skills/x/SKILL.md`):
+     *  the server skips hidden folders other than the ones it knows hold skills, and
+     *  `.cursor` or `.gemini` are not among them. */
+    path: string;
+    abs: string;
+    size: number;
+    mtimeMs: number;
+}
+/**
+ * Every file under each skills folder that exists.
+ *
+ * A link is followed only where it stays inside what the candidate agreed to share.
+ * An entry directly under a skills folder may be a link (a skill kept in dotfiles and
+ * linked in is common), and it sets the boundary: below it, a file or folder whose
+ * real path leaves that entry is not collected, so a link in a skill cannot carry an
+ * unrelated file off the laptop under the skill's name.
+ */
+export declare function collectSkillFiles(home?: string): LocalSkillFile[];
+export declare const MAX_UPLOAD_BYTES: number;
+export declare const MAX_UPLOAD_FILES = 1000;
+/** Why these files cannot be uploaded in one import, or null when they fit. */
+export declare function overUploadCaps(files: LocalSkillFile[]): string | null;
+export interface SkillPlanRequest {
+    /** Leave out a skill the server cannot read and name it in `refused`, rather than
+     *  refusing every skill over one malformed SKILL.md. */
+    skipInvalid: true;
+    paths: string[];
+    skillFiles: Record<string, string>;
+    unreadable: string[];
+    truncated: string[];
+}
+/** The plan route's body: every path, and the head of each SKILL.md. */
+export declare function planRequest(files: LocalSkillFile[]): SkillPlanRequest;
+/** The skill folder names among the paths the server said to send, for the prompt. */
+export declare function skillNames(kept: string[]): string[];
+/**
+ * What the candidate was last asked about, per assessment, so a candidate who
+ * reconnects every day of a work trial is asked again only when their skills changed.
+ * A digest of the kept files' paths, sizes and modification times: cheap, and any
+ * edit to a skill changes it.
+ */
+export declare function skillSetDigest(files: LocalSkillFile[]): string;
+export declare function lastAnswered(assessmentId: string, home?: string): string | null;
+/** Best effort: failing to remember only means being asked again next time. */
+export declare function rememberAnswered(assessmentId: string, digest: string, home?: string): void;
+export interface SkillImportResult {
+    installed: string[];
+    skipped: {
+        name: string;
+        dest: string;
+        reason: string;
+    }[];
+    ignored: string[];
+    duplicates: string[];
+    aider: string | null;
+}
+/** What the import did, in the same words the assessment page's dialog uses. */
+export declare function importSummaryLines(result: SkillImportResult): string[];
+export declare const SKILLS_PICKUP = "Start a new Claude Code or Codex session to use them. In Copilot, run /skills reload.";
+//# sourceMappingURL=skill-import.d.ts.map

package/dist/lib/skill-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-import.d.ts","sourceRoot":"","sources":["../../src/lib/skill-import.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAOvE,CAAA;AAUD,eAAO,MAAM,eAAe,QAAY,CAAA;AAExC,MAAM,WAAW,cAAc;IAC7B;;qDAEiD;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAQD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,MAAqB,GAAG,cAAc,EAAE,CAiD/E;AAID,eAAO,MAAM,gBAAgB,QAAmB,CAAA;AAChD,eAAO,MAAM,gBAAgB,OAAO,CAAA;AAEpC,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,MAAM,GAAG,IAAI,CAKrE;AAED,MAAM,WAAW,gBAAgB;IAC/B;4DACwD;IACxD,WAAW,EAAE,IAAI,CAAA;IACjB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,gBAAgB,CAkBrE;AAED,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAOnD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,MAAM,CAM9D;AAMD,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,GAAE,MAAqB,GAAG,MAAM,GAAG,IAAI,CAQ7F;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,MAAqB,GAAG,IAAI,CAexG;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzD,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAQD,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAgBtE;AAED,eAAO,MAAM,aAAa,0FAA0F,CAAA"}