@useshifu/coding-harness 0.3.5 → 0.3.7

package/README.md

@@ -20,7 +20,7 @@ For named meeting transcripts, set your display name in Shifu Profile so your sp
 
 The shortcuts are symlinks to the same folder, not additional watched folders. An existing conflicting `Shifu` item is left untouched and reported. To choose another existing, readable folder, use `--input-folder <path>` with `connect` or `config update`; Shifu checks the path before saving the change. No macOS permission flow is required by the CLI.
 
-No content is sent during setup. Every `connect` asks for a connection key and verifies it with Shifu for the chosen coding tool before saving it or reporting success. An invalid key or unreachable server leaves the existing connection unchanged. Replacing a key resets local checkpoints so existing work can be reconsidered for the new connection; the selected sync policy remains. If a coding tool cannot run `npx` or accept hidden input in its tool terminal, run the same command in your own interactive terminal and check the confirmation output. Change the choices later with:
+No content is sent during setup. Every `connect` asks for a connection key using a normal terminal prompt, so the key is visible as you type or paste it. The key is verified with Shifu for the chosen coding tool before saving it or reporting success. An invalid key or unreachable server leaves the existing connection unchanged. Replacing a key resets local checkpoints so existing work can be reconsidered for the new connection; the selected sync policy remains. If a coding tool cannot run `npx` or accept input in its tool terminal, run the same command in your own interactive terminal and check the confirmation output. Change the choices later with:
 
 ```sh
 npx --yes @useshifu/coding-harness config update --harness <codex|claude_code|opencode> --interval-hours 1 --approval-mode automatic --input-folder ~/Desktop/Shifu
@@ -47,7 +47,7 @@ The same scheduled run checks the input folder. `sync-files` checks it immediate
 
 The file-job result reports published claims separately from needs-evidence suggestions. A `no_claims` result can still contain suggestions: these are possible contributions awaiting evidence or attribution, not verified claims. The runner reports the suggestion count but never labels those suggestions as established work. It does not print the file's text, candidate statements, or source excerpts to logs. Use Shifu to inspect the suggestions and their evidence status. A result with zero claims and zero suggestions means no user-attributable contribution was extracted; it does not mean the upload failed.
 
-The connector captures supported harness work in engineering, product discovery, writing, interview feedback, research, and planning. Automatic sync turns completed actions and known work topics into separate controlled statements without sending source prose. If a segment has no supported work items, it advances the checkpoint without creating a claim. Version 1–3 clients remain supported.
+The connector captures supported harness work in engineering, product discovery, writing, interview feedback, research, and planning. Automatic sync turns completed actions, known work topics, descriptive feature or project types, and supported problem or approach details into separate controlled statements without sending source prose or raw names. If a segment has no supported work items, it advances the checkpoint without creating a claim. Version 1–3 clients remain supported.
 
 ## Sync a prepared payload
 
@@ -56,3 +56,11 @@ printf '%s' '{"harness":"codex","sessionRef":"opaque-session-id","fromTurn":1,"t
 ```
 
 Automatic mode sends immediately. Manual mode asks once unless the calling harness already obtained approval and passes `--approved`.
+
+## AI Profile observations
+
+AI Profile observations are created automatically with each coding-session activity sync, under the same sync policy. The local runner reads user turns to detect a small set of behavioral signals, then sends only fixed, redacted statements and turn numbers. It never sends prompts, transcripts, tool output, code, file paths, names, or secrets for AI Profile. Model and thinking labels are included only when recognized in local harness metadata. If an observation fails, its redacted payload remains in a local retry queue while activity sync continues; an already accepted observation is kept.
+
+The category is one of `system_design`, `detailed_design`, `implementation`, `debugging_testing`, `production_support`, `research_analysis`, `product_planning`, `writing_communication`, `marketing_growth`, `learning`, or `other`. Evidence dimensions are `task_selection`, `goal_clarity`, `context_sharing`, `constraint_setting`, `work_decomposition`, `iterative_steering`, `critical_judgment`, `verification`, `application`, and `responsible_use`. Automatic observations cite the relevant turn and never infer a limiting behavior from silence. Unsupported dimensions remain unscored.
+
+The AI Profile page shows detected categories, model and thinking labels, and Jev scores supported by these limited observations. Local signals do not prove work quality or establish that another model setting would have performed better. Identical retries are safe.

package/bin/shifu-harness.js

@@ -6,7 +6,6 @@ const os = require("node:os");
 const path = require("node:path");
 const { execFileSync } = require("node:child_process");
 const readline = require("node:readline/promises");
-const tty = require("node:tty");
 
 const DEFAULT_API_URL = "https://api.useshifu.com";
 const HARNESS_NAMES = {
@@ -25,6 +24,10 @@ const CLOUD_CREDENTIAL_PATTERN = /\bAKIA[0-9A-Z]{16}\b|AIza[0-9A-Za-z_-]{20,}/;
 const EVIDENCE_KINDS = new Set(["implementation", "decision", "activity"]);
 const EVIDENCE_FIELDS = new Set(["kind", "title", "statement", "scope", "area", "itemRef", "verificationRefs"]);
 const SYNC_FIELDS = new Set(["harness", "sessionRef", "fromTurn", "toTurn", "title", "summary", "evidence", "verification", "decisions", "redactionVersion"]);
+const AI_PROFILE_FIELDS = new Set(["harness", "sessionRef", "fromTurn", "toTurn", "category", "model", "thinking", "evidence"]);
+const AI_PROFILE_EVIDENCE_FIELDS = new Set(["dimension", "statement", "signal", "turn"]);
+const AI_PROFILE_DIMENSIONS = new Set(["task_selection", "goal_clarity", "context_sharing", "constraint_setting", "work_decomposition", "iterative_steering", "critical_judgment", "verification", "application", "responsible_use"]);
+const AI_PROFILE_CATEGORIES = new Set(["system_design", "detailed_design", "implementation", "debugging_testing", "production_support", "research_analysis", "product_planning", "writing_communication", "marketing_growth", "learning", "other"]);
 const SCOPE_LEVELS = new Set(["unit", "module", "service", "system", "product"]);
 const WORK_AREAS = new Set(["architecture", "api", "backend", "connector", "database", "documentation", "frontend", "performance", "security", "testing", "tooling"]);
 const ITEM_REF_PATTERN = /^[A-Za-z0-9_-]{1,80}$/;
@@ -509,12 +512,17 @@ function opencodeReview(sessionRef, fromTurn, toTurn) {
 
 function reviewSegment(harness, sessionRef, fromTurn, toTurn) {
   if (harness === "opencode") return opencodeReview(sessionRef, fromTurn, toTurn);
+  const selectedFile = sessionFile(harness, sessionRef);
+  return harness === "codex" ? codexReview(selectedFile, fromTurn, toTurn) : claudeReview(selectedFile, fromTurn, toTurn);
+}
+
+function sessionFile(harness, sessionRef) {
   const files = harness === "codex" ? sessionFiles(codexSessionsRoot()) : sessionFiles(claudeSessionsRoot());
   const selectedFile = files.map((file) => ({ file, session: harness === "codex" ? codexSession(file) : claudeSession(file) }))
     .filter(({ session }) => session?.sessionRef === sessionRef)
     .sort((left, right) => right.session.turnCount - left.session.turnCount || right.session.updatedAt.localeCompare(left.session.updatedAt))[0]?.file;
   if (!selectedFile) throw new Error(`No local ${HARNESS_NAMES[harness]} session matches ${sessionRef}.`);
-  return harness === "codex" ? codexReview(selectedFile, fromTurn, toTurn) : claudeReview(selectedFile, fromTurn, toTurn);
+  return selectedFile;
 }
 
 function reviewCandidates(notes) {
@@ -579,23 +587,107 @@ const WORK_OBJECTS = [
   { key: "planning", title: "project plan", pattern: /\b(?:roadmap|project plan|delivery plan)\b/i },
 ];
 
+// Only controlled feature descriptions leave the device during unattended sync.
+const WORK_CONTEXTS = [
+  { key: "payment_reconciliation", title: "payment reconciliation flow", phrase: "a payment reconciliation flow", pattern: /\bpayment reconciliation\b/i },
+  { key: "payment", title: "payment flow", phrase: "a payment flow", pattern: /\b(?:payment|payments|payout|payouts)\b/i },
+  { key: "checkout", title: "checkout flow", phrase: "a checkout flow", pattern: /\bcheckout\b/i },
+  { key: "billing", title: "billing flow", phrase: "a billing flow", pattern: /\b(?:billing|invoic(?:e|es|ing)|subscription|subscriptions)\b/i },
+  { key: "reconciliation", title: "reconciliation flow", phrase: "a reconciliation flow", pattern: /\breconciliation\b/i },
+  { key: "onboarding", title: "onboarding flow", phrase: "an onboarding flow", pattern: /\bonboarding\b/i },
+  { key: "search", title: "search experience", phrase: "a search experience", pattern: /\bsearch\b/i },
+  { key: "notification", title: "notification flow", phrase: "a notification flow", pattern: /\bnotifications?\b/i },
+  { key: "reporting", title: "reporting feature", phrase: "a reporting feature", pattern: /\b(?:reporting|reports)\b/i },
+  { key: "messaging", title: "messaging feature", phrase: "a messaging feature", pattern: /\bmessaging\b/i },
+  { key: "file_upload", title: "file upload flow", phrase: "a file upload flow", pattern: /\b(?:file uploads?|document uploads?)\b/i },
+  { key: "scheduling", title: "scheduling flow", phrase: "a scheduling flow", pattern: /\b(?:scheduling|booking)\b/i },
+  { key: "analytics", title: "analytics feature", phrase: "an analytics feature", pattern: /\banalytics\b/i },
+  { key: "data_import", title: "data import flow", phrase: "a data import flow", pattern: /\b(?:data import|csv import|bulk import)\b/i },
+  { key: "document_processing", title: "document processing flow", phrase: "a document processing flow", pattern: /\bdocument processing\b/i },
+];
+
+const WORK_DETAILS = [
+  { title: "timeouts", pattern: /\btimeouts?\b/i },
+  { title: "duplicates", pattern: /\bduplicat(?:e|es|ed|ion)\b/i },
+  { title: "stale data", pattern: /\bstale (?:data|results?|cache)\b/i },
+  { title: "race conditions", pattern: /\brace conditions?\b/i },
+  { title: "data loss", pattern: /\bdata loss\b/i },
+  { title: "latency", pattern: /\b(?:latency|slow responses?)\b/i },
+  { title: "idempotency", pattern: /\bidempoten(?:t|cy)\b/i },
+  { title: "backoff", pattern: /\bbackoff\b/i },
+  { title: "validation", pattern: /\bvalidat(?:e|ed|ion|ing)\b/i },
+  { title: "pagination", pattern: /\bpaginat(?:e|ed|ion|ing)\b/i },
+  { title: "batching", pattern: /\bbatch(?:es|ed|ing)?\b/i },
+  { title: "rate limiting", pattern: /\brate limit(?:s|ing|ed)?\b/i },
+  { title: "deduplication", pattern: /\bdedupl?icat(?:e|ed|ion|ing)\b/i },
+  { title: "fallback behavior", pattern: /\bfallback\b/i },
+  { title: "accessibility", pattern: /\baccessibility\b/i },
+  { title: "mobile layout", pattern: /\bmobile layout\b/i },
+];
+
+function controlledContexts(text) {
+  const matches = WORK_CONTEXTS.flatMap((item) => {
+    const match = item.pattern.exec(text);
+    if (!match) return [];
+    const type = text.slice(match.index + match[0].length).match(/^\s+(service|platform|system|feature|project|workflow|flow|experience)\b/i)?.[1];
+    if (!type) return [item];
+    const title = `${item.title.replace(/ (?:flow|feature|experience)$/, "")} ${type.toLowerCase()}`;
+    return [{ ...item, title, phrase: `${item.phrase.startsWith("an ") ? "an" : "a"} ${title}` }];
+  });
+  const contexts = matches.some((item) => item.key === "payment_reconciliation") ? matches.filter((item) => item.key !== "payment" && item.key !== "reconciliation") : matches;
+  return contexts.length <= 2 ? contexts : null;
+}
+
+function controlledDetails(text) {
+  return WORK_DETAILS.map((item) => ({ item, index: item.pattern.exec(text)?.index }))
+    .filter(({ index }) => index !== undefined)
+    .sort((left, right) => left.index - right.index)
+    .slice(0, 3)
+    .map(({ item }) => item.title);
+}
+
+function withoutNamedLabels(text) {
+  return text.replace(/\b(?:Project|Client|Customer|Company)\s+[A-Z][A-Za-z0-9_-]*/g, "");
+}
+
 function safeActivityEvidence(notes) {
   const evidence = [];
   const seen = new Set();
   for (const [noteIndex, { turn, note }] of notes.entries()) {
     let inCodeBlock = false;
+    let sectionContexts = [];
     for (const [lineIndex, rawLine] of note.split("\n").entries()) {
       if (rawLine.trim().startsWith("```")) { inCodeBlock = !inCodeBlock; continue; }
       if (inCodeBlock) continue;
+      const heading = rawLine.trim().match(/^(?:#{1,6}\s+(.+)|\*\*(.+)\*\*:?\s*)$/);
+      if (heading) {
+        const label = withoutNamedLabels(heading[1] || heading[2]);
+        sectionContexts = /\b(?:project|feature|flow|service|system|product)\b/i.test(label) ? controlledContexts(label) || [] : [];
+        continue;
+      }
       const line = rawLine.trim().replace(/^[-*]\s+/, "").split(/[.;—]/, 1)[0];
+      const clauses = line.split(/\s+(?:and|but|while)\s+/i);
+      const nextAction = clauses.findIndex((clause, index) => index > 0 && WORK_ACTIONS.some((item) => item.pattern.test(clause)));
+      const workClause = withoutNamedLabels(nextAction > 0 ? clauses.slice(0, nextAction).join(" and ") : line);
       const action = WORK_ACTIONS.find((item) => item.pattern.test(line));
-      const object = WORK_OBJECTS.find((item) => item.pattern.test(line));
+      const detailSource = workClause.split(/\b(?:about|titled)\b/i, 1)[0];
+      const contexts = controlledContexts(detailSource);
+      const featureContexts = contexts === null ? [] : contexts.length ? contexts : sectionContexts;
+      let object;
+      let objectPosition = Infinity;
+      for (const item of WORK_OBJECTS) {
+        const match = item.pattern.exec(workClause);
+        if (match && match.index < objectPosition) { object = item; objectPosition = match.index; }
+      }
+      object ||= featureContexts[0];
       if (!action || !object) continue;
-      const key = `${action.key}:${object.key}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      const title = `${action.title} ${object.title}`;
-      evidence.push({ kind: "activity", title, statement: `${title}.`, itemRef: `t${turn}_n${noteIndex + 1}_l${lineIndex + 1}` });
+      const context = ["interview_feedback", "professional_post"].includes(object.key) ? [] : featureContexts.filter((item) => item !== object);
+      const details = controlledDetails(detailSource).filter((detail) => !object.title.includes(detail));
+      const title = `${action.title} ${object.title}${context.length ? ` for ${context.map((item) => item.phrase).join(" and ")}` : ""}`;
+      const statement = `${title}${details.length ? ` (${details.join(", ")})` : ""}.`;
+      if (seen.has(statement)) continue;
+      seen.add(statement);
+      evidence.push({ kind: "activity", title, statement, itemRef: `t${turn}_n${noteIndex + 1}_l${lineIndex + 1}` });
       if (evidence.length === MAX_EVIDENCE_ITEMS) return evidence;
     }
   }
@@ -606,8 +698,8 @@ function payloadForSegment(harness, segment) {
   const { notes } = reviewSegment(harness, segment.sessionRef, segment.fromTurn, segment.toTurn);
   const evidence = safeActivityEvidence(notes);
   const title = evidence.length ? evidence[0].title : "No supported work identified";
-  const summary = evidence.length > 1 ? `${evidence[0].statement} ${evidence.length - 1} more supported work items.` :
-    evidence.length === 1 ? evidence[0].statement : "This range had no supported work items.";
+  const summary = evidence.length ? `${evidence.slice(0, 3).map((item) => item.statement).join(" ")}${evidence.length > 3 ? ` ${evidence.length - 3} more supported work items.` : ""}` :
+    "This range had no supported work items.";
   return {
     harness,
     sessionRef: segment.sessionRef,
@@ -622,6 +714,129 @@ function payloadForSegment(harness, segment) {
   };
 }
 
+const PROFILE_SIGNALS = [
+  { dimension: "task_selection", pattern: /\b(?:use (?:ai|an? agent) (?:to|for)|ask (?:ai|an? agent) to|delegate .+ to (?:ai|an? agent))\b/i, statement: "User explicitly chose a task to delegate to AI." },
+  { dimension: "goal_clarity", pattern: /\b(?:build|create|write|draft|implement|fix|design|produce)\b/i, statement: "User named a concrete deliverable or change." },
+  { dimension: "context_sharing", pattern: /\b(?:context|background|for example|here is)\b/i, statement: "User provided background or an example for the task." },
+  { dimension: "constraint_setting", pattern: /\b(?:must|only|without|avoid|do not|don't|should not|cannot|can't)\b/i, statement: "User stated an explicit constraint on the work." },
+  { dimension: "work_decomposition", pattern: /(?:^|\n)\s*(?:\d+[.)]|[-*])\s|\bfirst\b[\s\S]*\bthen\b/i, statement: "User broke the request into steps or listed parts." },
+  { dimension: "critical_judgment", pattern: /\b(?:compare|alternative|tradeoffs?|why|challenge|question the assumption)\b/i, statement: "User asked to examine a reason or alternative." },
+  { dimension: "verification", pattern: /\b(?:test|verify|validate|check|review the diff|prove)\b/i, statement: "User requested a check or test of the result." },
+  { dimension: "application", pattern: /\b(?:deploy|ship|publish|merge|release)\b/i, statement: "User requested that the result be put into use." },
+  { dimension: "responsible_use", pattern: /\b(?:redact|privacy|private data|raw data|secret|credential|permission)\b/i, statement: "User called out a privacy, secret, or permission boundary." },
+];
+const ITERATION_PATTERN = /\b(?:instead|change|revise|adjust|fix|more|less|not what|actually)\b/i;
+const PROFILE_CATEGORIZATION = [
+  { category: "production_support", pattern: /\b(?:incident|outage|production support|on.call)\b/i },
+  { category: "debugging_testing", pattern: /\b(?:debug|bug|failing test|regression|troubleshoot)\b/i },
+  { category: "system_design", pattern: /\b(?:system design|architecture|high.level design|hld)\b/i },
+  { category: "detailed_design", pattern: /\b(?:detailed design|low.level design|lld|api design|schema design)\b/i },
+  { category: "marketing_growth", pattern: /\b(?:marketing|growth|campaign|conversion)\b/i },
+  { category: "writing_communication", pattern: /\b(?:write|draft|article|post|email|feedback|documentation)\b/i },
+  { category: "research_analysis", pattern: /\b(?:research|analy[sz]e|compare|investigate)\b/i },
+  { category: "product_planning", pattern: /\b(?:roadmap|product plan|feature plan|prioriti[sz]e)\b/i },
+  { category: "learning", pattern: /\b(?:learn|explain|teach|tutorial)\b/i },
+  { category: "implementation", pattern: /\b(?:implement|build|code|refactor|frontend|backend|api|test)\b/i },
+];
+
+function canonicalModel(value) {
+  if (typeof value !== "string") return undefined;
+  const known = value.match(/^(gpt-(?:6-(?:astra|sol|luna)|5\.6-(?:sol|terra|luna)|5\.5)|o[134](?:-mini)?)(?:$|[-.])/i);
+  if (known) return known[1].toLowerCase();
+  const claude = value.match(/^claude-(opus|sonnet|haiku)-(\d+(?:-\d+)?)(?:$|-)/i);
+  return claude ? `claude-${claude[1].toLowerCase()}-${claude[2]}` : undefined;
+}
+
+function canonicalThinking(value) {
+  return ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"].includes(value) ? value : undefined;
+}
+
+function localProfileTurns(harness, segment) {
+  const turns = [];
+  if (harness === "opencode") {
+    const rows = opencodeQuery(`SELECT m.id AS messageId, json_extract(m.data, '$.role') AS role, json_extract(m.data, '$.modelID') AS model, p.data AS part FROM message m LEFT JOIN part p ON p.message_id = m.id WHERE m.session_id = ${JSON.stringify(segment.sessionRef)} ORDER BY m.time_created, p.id`);
+    let lastMessage;
+    let turn = 0;
+    for (const row of rows) {
+      if (row.messageId !== lastMessage) {
+        lastMessage = row.messageId;
+        if (row.role === "user") { turn += 1; turns.push({ turn, text: "" }); }
+        if (row.role === "assistant" && turn > 0) turns[turn - 1].model ||= canonicalModel(row.model);
+      }
+      if (row.role !== "user" || turn === 0 || typeof row.part !== "string") continue;
+      try { const part = JSON.parse(row.part); if (part.type === "text" && typeof part.text === "string") turns[turn - 1].text += part.text; } catch {}
+    }
+  } else if (harness === "claude_code") {
+    let turn = 0;
+    for (const entry of claudeEntries(sessionFile(harness, segment.sessionRef))) {
+      if (isClaudeUserTurn(entry)) {
+        turn += 1;
+        const content = entry.message.content;
+        turns.push({ turn, text: typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("\n") });
+      } else if (entry.type === "assistant" && turn > 0) {
+        turns[turn - 1].model ||= canonicalModel(entry.message?.model);
+      }
+    }
+  } else {
+    let turn = 0;
+    for (const line of fs.readFileSync(sessionFile(harness, segment.sessionRef), "utf8").split("\n")) {
+      if (!line) continue;
+      const entry = JSON.parse(line);
+      if (entry.type === "response_item" && entry.payload?.type === "message" && entry.payload.role === "user") {
+        turn += 1;
+        turns.push({ turn, text: entry.payload.content?.filter((part) => part.type === "input_text").map((part) => part.text).join("\n") || "" });
+      } else if (entry.type === "turn_context" && turn > 0) {
+        turns[turn - 1].model ||= canonicalModel(entry.payload?.model);
+        turns[turn - 1].thinking ||= canonicalThinking(entry.payload?.effort);
+      }
+    }
+  }
+  return turns.filter(({ turn }) => turn >= segment.fromTurn && turn <= segment.toTurn);
+}
+
+function profileForSegment(harness, segment) {
+  const turns = localProfileTurns(harness, segment);
+  if (turns.length !== segment.toTurn - segment.fromTurn + 1) throw new Error("The AI Profile source turns were not found locally; the segment remains pending.");
+  const evidence = [];
+  const observed = new Set();
+  const categories = [];
+  for (const { turn, text } of turns) {
+    for (const signal of PROFILE_SIGNALS) {
+      if (!observed.has(signal.dimension) && signal.pattern.test(text)) {
+        evidence.push({ dimension: signal.dimension, statement: signal.statement, signal: "demonstrated", turn });
+        observed.add(signal.dimension);
+      }
+    }
+    if (turn > 1 && !observed.has("iterative_steering") && ITERATION_PATTERN.test(text)) {
+      evidence.push({ dimension: "iterative_steering", statement: "User gave a follow-up direction to change the work.", signal: "demonstrated", turn });
+      observed.add("iterative_steering");
+    }
+    const category = PROFILE_CATEGORIZATION.find((item) => item.pattern.test(text))?.category;
+    if (category) categories.push(category);
+  }
+  const models = [...new Set(turns.map((turn) => turn.model).filter(Boolean))];
+  const thinking = [...new Set(turns.map((turn) => turn.thinking).filter(Boolean))];
+  const observation = {
+    harness, sessionRef: segment.sessionRef, fromTurn: segment.fromTurn, toTurn: segment.toTurn,
+    category: categories[0] || "other", evidence,
+  };
+  if (models.length === 1 && turns.every((turn) => turn.model)) observation.model = models[0];
+  if (thinking.length === 1 && turns.every((turn) => turn.thinking)) observation.thinking = thinking[0];
+  validateGeneratedProfile(observation, harness);
+  return observation;
+}
+
+function validateGeneratedProfile(profile, harness) {
+  validateAIProfileObservation(profile, harness);
+  const statements = new Map(PROFILE_SIGNALS.map((signal) => [signal.dimension, signal.statement]));
+  statements.set("iterative_steering", "User gave a follow-up direction to change the work.");
+  if (profile.evidence.some((item) => item.signal !== "demonstrated" || statements.get(item.dimension) !== item.statement) ||
+    (profile.model !== undefined && canonicalModel(profile.model) !== profile.model) ||
+    (profile.thinking !== undefined && canonicalThinking(profile.thinking) !== profile.thinking)) {
+    throw new Error("Only locally generated AI Profile signals may be synced.");
+  }
+}
+
 function unsyncedCodexSessions(harness, hours, turns = MAX_TURNS_PER_SEGMENT, selectedRef, includeOlder = false) {
   if (![24, 48, 72].includes(hours)) throw new Error("Choose --hours 24, 48, or 72.");
   if (!Number.isInteger(turns) || turns < 1 || turns > MAX_TURNS_PER_SEGMENT) throw new Error("Choose --turns between 1 and 12.");
@@ -701,41 +916,17 @@ async function confirm(question) {
   }
 }
 
-async function readSecret(input = process.stdin) {
-  const ownsInput = !input.isTTY;
-  if (ownsInput) {
-    let descriptor;
-    try { descriptor = fs.openSync(process.platform === "win32" ? "CONIN$" : "/dev/tty", "r"); }
-    catch { throw new Error("This terminal cannot accept a hidden connection key. Run connect in your own interactive terminal."); }
-    input = new tty.ReadStream(descriptor);
+async function readSecret(input = process.stdin, output = process.stderr) {
+  const terminal = readline.createInterface({ input, output });
+  try {
+    const answer = terminal.question("Connection key: ");
+    const closed = new Promise((_, reject) => terminal.once("close", () => reject(new Error("Connection key input closed."))));
+    return await Promise.race([answer, closed]);
+  } catch {
+    throw new Error("Could not read a connection key. Run connect in an interactive terminal.");
+  } finally {
+    terminal.close();
   }
-  const wasRaw = input.isRaw;
-  process.stderr.write("Connection key (hidden): ");
-  input.setRawMode(true);
-  input.setEncoding("utf8");
-  return new Promise((resolve, reject) => {
-    let value = "";
-    const finish = (error) => {
-      input.off("data", onData);
-      input.off("error", onError);
-      input.setRawMode(Boolean(wasRaw));
-      if (ownsInput) input.destroy();
-      process.stderr.write("\n");
-      if (error) reject(error);
-      else resolve(value);
-    };
-    const onError = (error) => finish(error);
-    const onData = (chunk) => {
-      for (const character of chunk) {
-        if (character === "\r" || character === "\n") return finish();
-        if (character === "\u0003") return finish(new Error("Connection was cancelled."));
-        if (character === "\u007f" || character === "\b") value = value.slice(0, -1);
-        else if (character >= " " && character !== "\u007f") value += character;
-      }
-    };
-    input.on("data", onData);
-    input.on("error", onError);
-  });
 }
 
 function copyRunner() {
@@ -1062,6 +1253,16 @@ function validateSync(input, harness) {
   if (input.redactionVersion !== 2 && input.redactionVersion !== 3 && input.redactionVersion !== REDACTION_VERSION) throw new Error(`Use redactionVersion ${REDACTION_VERSION} for new syncs.`);
 }
 
+function validateAIProfileObservation(input, harness) {
+  if (!input || typeof input !== "object" || Object.keys(input).some((field) => !AI_PROFILE_FIELDS.has(field)) || input.harness !== harness || typeof input.sessionRef !== "string" || !/^[A-Za-z0-9_-]{8,200}$/.test(input.sessionRef)) throw new Error("Use a reviewed AI Profile observation for this harness and an opaque session reference.");
+  if (!Number.isInteger(input.fromTurn) || !Number.isInteger(input.toTurn) || input.fromTurn < 1 || input.toTurn < input.fromTurn || input.toTurn > 1_000_000 || input.toTurn - input.fromTurn >= MAX_TURNS_PER_SEGMENT) throw new Error("Use a valid range of at most 12 turns.");
+  if (!AI_PROFILE_CATEGORIES.has(input.category)) throw new Error("Choose a supported AI Profile category.");
+  for (const field of ["model", "thinking"]) {
+    if (input[field] !== undefined && (typeof input[field] !== "string" || input[field].length > (field === "model" ? 100 : 40) || /[\x00-\x1f\x7f\\@`<>]/.test(input[field]) || input[field].includes("://") || ["secret", "sk-", "ghp_"].some((part) => input[field].toLowerCase().includes(part)))) throw new Error(`Use safe ${field} metadata or omit it.`);
+  }
+  if (!Array.isArray(input.evidence) || input.evidence.length > 20 || !input.evidence.every((item) => item && typeof item === "object" && Object.keys(item).every((field) => AI_PROFILE_EVIDENCE_FIELDS.has(field)) && AI_PROFILE_DIMENSIONS.has(item.dimension) && ["demonstrated", "limiting"].includes(item.signal) && Number.isInteger(item.turn) && item.turn >= input.fromTurn && item.turn <= input.toTurn && textIsSafe(item.statement, 240))) throw new Error("Use at most 20 redacted, turn-cited AI-use observations; omit unsupported claims.");
+}
+
 function validSyncReceipt(receipt, input) {
   return receipt?.sessionRef === input.sessionRef && receipt.acceptedToTurn === input.toTurn && Number.isInteger(receipt.lastSyncedTurn) &&
     (receipt.duplicate ? receipt.lastSyncedTurn >= input.toTurn : receipt.lastSyncedTurn === input.toTurn);
@@ -1106,6 +1307,28 @@ async function postSync(config, input) {
   throw lastError;
 }
 
+async function flushPendingProfiles(harness, config) {
+  const pending = readState(harness).profilePending || {};
+  for (const [key, profile] of Object.entries(pending)) {
+    try {
+      validateGeneratedProfile(profile, harness);
+      const response = await fetch(`${config.apiUrl}/v1/connectors/coding-sessions/ai-profile-observations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.token}` },
+        body: JSON.stringify(profile),
+        signal: AbortSignal.timeout(30_000),
+      });
+      const receipt = await response.json().catch(() => undefined);
+      if (response.status !== 409 && (!response.ok || receipt?.data?.accepted !== true)) throw new Error(`HTTP ${response.status}`);
+      const state = readState(harness);
+      delete state.profilePending[key];
+      saveState(harness, state);
+    } catch {
+      console.error(`AI Profile observation for ${profile.sessionRef} turns ${profile.fromTurn}–${profile.toTurn} remains pending.`);
+    }
+  }
+}
+
 function scanWorkFiles(folder) {
   const entries = fs.readdirSync(validateInputFolder(folder), { withFileTypes: true })
     .filter((entry) => entry.isFile() && entry.name !== INPUT_FOLDER_README_NAME);
@@ -1289,12 +1512,16 @@ async function sendSync(harness, input, config = readConfig(harness)) {
   const checkpoint = state.sessions[input.sessionRef];
   const expected = (checkpoint?.lastSyncedTurn || 0) + 1;
   if (input.fromTurn !== expected) throw new Error(`This local checkpoint expects turn ${expected}. Review the pending segment before retrying.`);
+  const profile = profileForSegment(harness, input);
   const receipt = await postSync(config, input);
   if (!validSyncReceipt(receipt, input)) {
     throw new Error("Shifu returned a checkpoint that does not match this reviewed segment. Local state was not advanced.");
   }
+  state.profilePending ||= {};
+  state.profilePending[`${profile.sessionRef}:${profile.fromTurn}:${profile.toTurn}`] = profile;
   state.sessions[input.sessionRef] = { turnsSinceSync: 0, lastSyncedAt: Date.now(), lastSyncedTurn: receipt.lastSyncedTurn, syncDue: false };
   saveState(harness, state);
+  await flushPendingProfiles(harness, config);
   console.error(receipt.duplicate ? "Shifu already had this exact segment. Local checkpoint recovered." : `Synced through turn ${receipt.lastSyncedTurn}.`);
   return receipt;
 }
@@ -1449,6 +1676,7 @@ async function scheduledSync(harness) {
         console.error(`Shifu input folder remains pending: ${error.message}`);
       }
     }
+    await flushPendingProfiles(harness, config);
     if (policy.approvalMode === "manual") {
       const queue = rebuildPendingQueue(harness);
       const pendingFingerprint = createHash("sha256").update(queue.segments.map((segment) => `${segment.sessionRef}:${segment.fromTurn}:${segment.toTurn}`).join("\n")).digest("hex");
@@ -1466,19 +1694,21 @@ async function scheduledSync(harness) {
           notificationError = error?.message || "Could not create the approval session.";
         }
       }
+      const pendingProfiles = Object.keys(readState(harness).profilePending || {}).length;
       state.schedule = {
         ...state.schedule,
         lastAttemptAt: startedAt,
-        lastResult: notificationError ? "awaiting_approval_notification_failed" : failedFiles ? "partial_failure" : "awaiting_approval",
+        lastResult: notificationError ? "awaiting_approval_notification_failed" : failedFiles || pendingProfiles ? "partial_failure" : "awaiting_approval",
         submittedFiles,
         pendingFiles,
         failedFiles,
         unsupportedFiles,
+        pendingProfiles,
         pendingSegments: queue.segments.length,
         pendingFingerprint,
         approvalSessionRef,
         notificationError,
-        nextRunAt: startedAt + (notificationError || failedFiles ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
+        nextRunAt: startedAt + (notificationError || failedFiles || pendingProfiles ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
       };
     } else {
       const blockedSessions = new Set();
@@ -1493,16 +1723,18 @@ async function scheduledSync(harness) {
           console.error(`${HARNESS_NAMES[harness]} session ${segment.sessionRef} remains pending: ${error.message}`);
         }
       }
+      const pendingProfiles = Object.keys(readState(harness).profilePending || {}).length;
       state.schedule = {
         lastAttemptAt: startedAt,
-        lastResult: failures || failedFiles ? "partial_failure" : "complete",
+        lastResult: failures || failedFiles || pendingProfiles ? "partial_failure" : "complete",
         syncedSegments: synced,
         failedSessions: failures,
         submittedFiles,
         pendingFiles,
         failedFiles,
         unsupportedFiles,
-        nextRunAt: startedAt + (failures || failedFiles ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
+        pendingProfiles,
+        nextRunAt: startedAt + (failures || failedFiles || pendingProfiles ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
       };
     }
     const latest = readState(harness);
@@ -1610,4 +1842,4 @@ if (require.main === module) {
     });
 }
 
-module.exports = { approvalNotificationInvocation, claudeReview, claudeSession, codexReview, codexSession, configPath, configuredSyncPolicy, connect, defaultInputFolder, disconnect, finalAssistantNote, install, installDestination, localSessions, normalizedPolicy, notificationSessionRef, opencodeQuery, opencodeReview, opencodeSessions, payloadForSegment, pendingSegments, prepareInputFolder, readSecret, removeHooks, requireSafeApiUrl, reviewCandidates, schedulerArtifact, statePath, syncWorkFiles, textIsSafe, unsyncedCodexSessions, validateConnection, validateInputFolder, validSyncReceipt, validateApprovalMode, validateIntervalHours, validateSync, workFiles };
+module.exports = { approvalNotificationInvocation, claudeReview, claudeSession, codexReview, codexSession, configPath, configuredSyncPolicy, connect, defaultInputFolder, disconnect, finalAssistantNote, install, installDestination, localSessions, normalizedPolicy, notificationSessionRef, opencodeQuery, opencodeReview, opencodeSessions, payloadForSegment, pendingSegments, prepareInputFolder, profileForSegment, readSecret, removeHooks, requireSafeApiUrl, reviewCandidates, schedulerArtifact, statePath, syncWorkFiles, textIsSafe, unsyncedCodexSessions, validateAIProfileObservation, validateConnection, validateInputFolder, validSyncReceipt, validateApprovalMode, validateIntervalHours, validateSync, workFiles };

package/commands/shifu-sync.md

@@ -12,8 +12,8 @@ For an explicit sync-now request:
 
 1. Run `sessions --harness opencode --hours 24`, using 48 or 72 only when requested.
 2. Review each returned segment with `review --harness opencode --session-ref <sessionRef> --hours <hours>`.
-3. Prepare a redaction-version-four payload from final assistant notes only. Use `activity` evidence for writing, feedback, research, planning, product work, and any work that is not clearly an engineering implementation or decision. Activity evidence has no technical scope. An empty evidence list advances the checkpoint without creating a claim.
+3. Prepare a redaction-version-four payload from final assistant notes only. Use `activity` evidence for writing, feedback, research, planning, product work, and any work that is not clearly an engineering implementation or decision. Activity evidence has no technical scope. Preserve the supported action, feature or project purpose, specific problem, approach, and verified result. Synthesize a descriptive project label (such as "payment reconciliation service") from its purpose; never copy a raw label that could identify a company or person. Keep distinct contributions separate, including different fixes within one feature. An empty evidence list advances the checkpoint without creating a claim.
 4. In automatic mode, pipe the payload to `sync --harness opencode` without asking again. In manual mode, show the exact payload, ask once, and then use `sync --approved --harness opencode`.
-5. Keep the returned session reference and turn range unchanged. Never upload prompts, raw transcripts, tool output, code, paths, commands, URLs, credentials, names, customer details, or proprietary identifiers.
+5. Keep the returned session reference and turn range unchanged. Never upload prompts, raw transcripts, tool output, code, paths, commands, URLs, credentials, company or person names, customer details, or proprietary identifiers.
 
-To connect or replace a key, run `npx --yes @useshifu/coding-harness connect --harness opencode`. Connect asks for a key and verifies it with Shifu before reporting success. If this tool terminal cannot run the command or accept hidden input, ask the user to run it in their own interactive terminal and report the output; do not claim the connection succeeded. To disconnect locally, run `npx --yes @useshifu/coding-harness disconnect --harness opencode`. New connections use one-hour automatic sync and `~/Desktop/Shifu` on macOS by default. To change the interval, approval policy, or folder later, run `config update --harness opencode` with the desired flags (for example, `--input-folder <existing-readable-folder>`).
+To connect or replace a key, run `npx --yes @useshifu/coding-harness connect --harness opencode`. Connect asks for a key with a normal visible terminal prompt and verifies it with Shifu before reporting success. Do not ask the user to paste the key into chat. If this tool terminal cannot run the command or accept input, ask the user to run it in their own interactive terminal and report the output; do not claim the connection succeeded. To disconnect locally, run `npx --yes @useshifu/coding-harness disconnect --harness opencode`. New connections use one-hour automatic sync and `~/Desktop/Shifu` on macOS by default. To change the interval, approval policy, or folder later, run `config update --harness opencode` with the desired flags (for example, `--input-folder <existing-readable-folder>`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useshifu/coding-harness",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Scheduled, redacted coding-harness activity sync for Shifu",
   "bin": {
     "coding-harness": "bin/shifu-harness.js",

package/skills/shifu-sync/SKILL.md

@@ -1,16 +1,20 @@
 ---
 name: shifu-sync
-description: Connect, configure, inspect, or sync coding-harness activity and local work files to Shifu. Use when the user asks to connect Shifu, change sync settings, inspect pending activity, approve a queued coding sync, or sync recent harness work or input-folder files.
+description: Connect, configure, inspect, or sync coding-harness activity, AI Profile observations, and local work files to Shifu. Use when the user asks to connect Shifu, change sync settings, inspect pending activity, approve a queued coding sync, or sync recent harness work, AI-use evidence, or input-folder files.
 ---
 
 # Shifu sync
 
 Shifu records useful work completed through the harness. Work may be engineering, product discovery, writing, interview feedback, research, planning, or another user-directed activity. Do not force non-engineering work into engineering categories.
 
-Never include user prompts, raw transcripts, tool output, source code, commands, credentials, URLs, file paths, names, customer details, or proprietary identifiers in a coding-session payload. The local coding runner reads final assistant notes only and enforces redaction and checkpoint rules. Files placed in the user's chosen Shifu input folder are a separate path: the runner sends supported files over TLS for server-side parsing and sanitization. Do not describe folder files as locally redacted.
+Never include user prompts, raw transcripts, tool output, source code, commands, credentials, URLs, file paths, company or person names, customer details, or proprietary identifiers in a coding-session payload. Synthesize descriptive project labels from their purpose rather than copying a raw name. The local coding runner reads final assistant notes for career activity and scans user turns locally for fixed AI Profile signals; it sends neither raw source. Files placed in the user's chosen Shifu input folder are a separate path: the runner sends supported files over TLS for server-side parsing and sanitization. Do not describe folder files as locally redacted.
 
 Only describe work attributable to the user. A team action item, meeting discussion, or another person's contribution is not evidence that the user did it. If a final note does not support a specific user contribution, do not invent one.
 
+## AI Profile observations
+
+Every accepted coding-session sync also queues a locally derived AI Profile observation for the same turns. No separate command or approval is needed. The runner sends only fixed statements for detected behavior and recognized model metadata, with no raw prompt text. Unsupported dimensions remain unscored. If profile scoring is unavailable, the redacted observation remains local for the next sync while activity sync continues.
+
 ## Connect or reconfigure
 
 When the user asks to connect, run:
@@ -19,7 +23,7 @@ When the user asks to connect, run:
 npx --yes @useshifu/coding-harness connect --harness codex
 ```
 
-`connect` asks for a key every time and verifies it against Shifu for this harness before reporting success. If this tool terminal cannot run npx or accept hidden input, ask the user to run the command in their own interactive terminal and report its output; do not claim the connection succeeded. It installs the current runner and a local schedule with no policy questions. New connections default to hourly automatic sync and `~/Desktop/Shifu` as the single input folder on macOS. It creates shortcuts at `~/Downloads/Shifu` and `~/Documents/Shifu` when possible without replacing conflicting items. Supported files are `.txt`, `.md`, `.rtf`, and `.docx` up to 20 MB directly inside the folder; images and screenshots are not supported. Unknown formats are counted but never uploaded. Replacing a key resets local checkpoints so work can sync to the new connection. It also excludes the setup session when the harness exposes its current opaque session reference. No content is sent during setup.
+`connect` asks for a key with a normal visible terminal prompt every time and verifies it against Shifu for this harness before reporting success. Do not ask the user to paste the key into chat. If this tool terminal cannot run npx or accept input, ask the user to run the command in their own interactive terminal and report its output; do not claim the connection succeeded. It installs the current runner and a local schedule with no policy questions. New connections default to hourly automatic sync and `~/Desktop/Shifu` as the single input folder on macOS. It creates shortcuts at `~/Downloads/Shifu` and `~/Documents/Shifu` when possible without replacing conflicting items. Supported files are `.txt`, `.md`, `.rtf`, and `.docx` up to 20 MB directly inside the folder; images and screenshots are not supported. Unknown formats are counted but never uploaded. Replacing a key resets local checkpoints so work can sync to the new connection. It also excludes the setup session when the harness exposes its current opaque session reference. No content is sent during setup.
 
 To disconnect locally, run `npx --yes @useshifu/coding-harness disconnect --harness codex`. Tell the user to revoke the old key in Shifu if they no longer want it usable.
 
@@ -60,6 +64,8 @@ For an explicit sync request, first read `status` to determine the saved approva
 
 Use `kind: "activity"` for general harness work; it does not require a technical scope. Use `implementation` or `decision` only when the note clearly supports that engineering classification, and then use the smallest reviewed scope among `unit`, `module`, `service`, `system`, and `product`. Evidence may be empty when the safe final note supports only a session-level title and summary. Never invent impact, ownership, verification, or outcomes.
 
+Make each supported item useful for later recall: retain the user's action, the feature or project purpose, the specific problem, the approach, and a verified result when the final note supports each part. A descriptive project label such as "payment reconciliation service" is useful; synthesize it from the work's purpose instead of copying a raw project label that might contain a company or person's name. Keep distinct contributions separate, including two fixes in one feature that addressed different problems. Omit names of companies and people, customer details, proprietary identifiers, paths, code snippets, and unsupported impact. If a detail cannot be safely described, keep the supported parts. Prefer a summary that names the main distinct work items over a generic count alone.
+
 ```json
 {
   "harness": "codex",