@useshifu/coding-harness 0.3.4 → 0.3.6

package/README.md

@@ -5,7 +5,7 @@
 ## Connect
 
 ```sh
-npx @useshifu/coding-harness connect --harness <codex|claude_code|opencode>
+npx --yes @useshifu/coding-harness connect --harness <codex|claude_code|opencode>
 ```
 
 Connect installs the local instruction and scheduled runner, saves the connection key with owner-only permissions, and uses these defaults without setup questions:
@@ -20,23 +20,25 @@ 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. Re-running `connect` on an older installation keeps its key, checkpoints, and selected sync policy. Change the choices later with:
+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:
 
 ```sh
-npx @useshifu/coding-harness config update --harness <codex|claude_code|opencode> --interval-hours 1 --approval-mode automatic --input-folder ~/Desktop/Shifu
+npx --yes @useshifu/coding-harness config update --harness <codex|claude_code|opencode> --interval-hours 1 --approval-mode automatic --input-folder ~/Desktop/Shifu
 ```
 
 Older configuration files remain on-demand and manual until either command completes onboarding; upgrading the package alone never enables background upload.
 
+To disconnect this device, run `npx --yes @useshifu/coding-harness disconnect --harness <codex|claude_code|opencode>`. This removes the local key, schedule, and checkpoints. It does not revoke the key on Shifu; revoke the old key there if it should no longer work.
+
 ## Operate
 
 ```sh
-npx @useshifu/coding-harness status --harness codex
-npx @useshifu/coding-harness sessions --harness codex --hours 24
-npx @useshifu/coding-harness review --harness codex --session-ref opaque-session-id
-npx @useshifu/coding-harness pending --harness codex
-npx @useshifu/coding-harness approve --harness codex
-npx @useshifu/coding-harness sync-files --harness codex
+npx --yes @useshifu/coding-harness status --harness codex
+npx --yes @useshifu/coding-harness sessions --harness codex --hours 24
+npx --yes @useshifu/coding-harness review --harness codex --session-ref opaque-session-id
+npx --yes @useshifu/coding-harness pending --harness codex
+npx --yes @useshifu/coding-harness approve --harness codex
+npx --yes @useshifu/coding-harness sync-files --harness codex
 ```
 
 Automatic scheduled runs send each accepted segment and advance its local checkpoint only after the server returns a matching receipt. Manual scheduled runs rebuild an accumulated local queue without advancing checkpoints and create or resume one content-free harness session when the pending count changes; one approval sends the queue in order. Network failures and server throttling are retried, while rejected segments stay pending.
@@ -45,12 +47,20 @@ 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 any useful harness activity, including engineering, product discovery, writing, interview feedback, research, and planning. Version-four payloads support generic `activity` items without a technical scope and accept a safe session-level summary when no item survives redaction. 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 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.
 
 ## Sync a prepared payload
 
 ```sh
-printf '%s' '{"harness":"codex","sessionRef":"opaque-session-id","fromTurn":1,"toTurn":3,"title":"Prepared structured interview feedback","summary":"Prepared structured interview feedback and clarified the recommendation.","evidence":[{"kind":"activity","title":"Drafted interview feedback","statement":"Prepared structured interview feedback."}],"verification":[],"decisions":[],"redactionVersion":4}' | npx @useshifu/coding-harness sync --harness codex
+printf '%s' '{"harness":"codex","sessionRef":"opaque-session-id","fromTurn":1,"toTurn":3,"title":"Prepared structured interview feedback","summary":"Prepared structured interview feedback and clarified the recommendation.","evidence":[{"kind":"activity","title":"Drafted interview feedback","statement":"Prepared structured interview feedback."}],"verification":[],"decisions":[],"redactionVersion":4}' | npx --yes @useshifu/coding-harness sync --harness codex
 ```
 
 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

@@ -25,6 +25,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 +513,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) {
@@ -543,41 +552,77 @@ function conciseTitle(statement, fallback) {
   return `${value.slice(0, MAX_TITLE_LENGTH - 1).trimEnd()}…`;
 }
 
-const ACTIVITY_CATEGORIES = [
-  { key: "interview_feedback", title: "Interview feedback", pattern: /\b(?:interview|candidate|hiring feedback)\b/i },
-  { key: "professional_writing", title: "Professional writing", pattern: /\b(?:linkedin|social post|article|newsletter|professional post|writing)\b/i },
-  { key: "product_discovery", title: "Product discovery", pattern: /\b(?:product discovery|user research|customer research|requirements?|roadmap)\b/i },
-  { key: "product_delivery", title: "Product and design delivery", pattern: /\b(?:landing page|website|user interface|user experience|design|prototype)\b/i },
-  { key: "research", title: "Research", pattern: /\b(?:research|investigat|compar|evaluat|analysis|analyz)\w*/i },
-  { key: "planning", title: "Planning", pattern: /\b(?:plan|strategy|prioriti|proposal|brief)\w*/i },
-  { key: "documentation", title: "Documentation", pattern: /\b(?:documentation|readme|guide|runbook)\b/i },
-  { key: "engineering", title: "Engineering", pattern: /\b(?:implement|code|bug|fix|test|api|database|frontend|backend|refactor|deploy)\w*/i },
+const WORK_ACTIONS = [
+  { key: "implemented", title: "Implemented", pattern: /^(?:I\s+|We\s+)?(?:implemented|added|built|shipped)\b/i },
+  { key: "fixed", title: "Fixed", pattern: /^(?:I\s+|We\s+)?(?:fixed|resolved|corrected)\b/i },
+  { key: "improved", title: "Improved", pattern: /^(?:I\s+|We\s+)?(?:improved|optimized|updated)\b/i },
+  { key: "refactored", title: "Refactored", pattern: /^(?:I\s+|We\s+)?refactored\b/i },
+  { key: "designed", title: "Designed", pattern: /^(?:I\s+|We\s+)?designed\b/i },
+  { key: "prepared", title: "Prepared", pattern: /^(?:I\s+|We\s+)?(?:prepared|drafted|wrote)\b/i },
+  { key: "reviewed", title: "Reviewed", pattern: /^(?:I\s+|We\s+)?(?:reviewed|audited)\b/i },
+  { key: "investigated", title: "Investigated", pattern: /^(?:I\s+|We\s+)?(?:investigated|researched|evaluated|compared)\b/i },
+  { key: "deployed", title: "Deployed", pattern: /^(?:I\s+|We\s+)?(?:deployed|published)\b/i },
 ];
 
-function safeActivityEvidence(notes, segment) {
-  const source = notes.map((note) => note.note).join("\n");
-  const categories = ACTIVITY_CATEGORIES.filter((category) => category.pattern.test(source));
-  if (categories.length === 0) return [];
-  return categories.map((category, index) => ({
-    kind: "activity",
-    title: category.title,
-    statement: `Used the harness for ${category.title.toLowerCase()}.`,
-    itemRef: `t${segment.fromTurn}_${category.key}_${index + 1}`,
-  }));
+const WORK_OBJECTS = [
+  { key: "interview_feedback", title: "interview feedback", pattern: /\b(?:interview feedback|candidate feedback|hiring feedback)\b/i },
+  { key: "professional_post", title: "professional writing", pattern: /\b(?:linkedin|social post|professional post|newsletter|article)\b/i },
+  { key: "home_review", title: "Home review", pattern: /\b(?:home review|work review|review on the home page)\b/i },
+  { key: "connection_key", title: "connection key validation", pattern: /\b(?:connection key|connector key|key validation)\b/i },
+  { key: "claim_extraction", title: "claim extraction", pattern: /\b(?:claim extraction|claim generation|claim matching)\b/i },
+  { key: "retry", title: "retry handling", pattern: /\b(?:retries|retry)\b/i },
+  { key: "cache", title: "cache behavior", pattern: /\b(?:cache|caching|ttl)\b/i },
+  { key: "navigation", title: "navigation", pattern: /\b(?:navigation|sidebar|sub.?nav)\b/i },
+  { key: "sync", title: "sync behavior", pattern: /\b(?:sync|synchronization|checkpoint)\b/i },
+  { key: "auth", title: "authentication", pattern: /\b(?:authentication|sign.?in|login)\b/i },
+  { key: "permissions", title: "access controls", pattern: /\b(?:authorization|permissions?|access control)\b/i },
+  { key: "database", title: "database migration", pattern: /\b(?:database migration|schema migration|postgres migration)\b/i },
+  { key: "api", title: "API endpoint", pattern: /\b(?:api|endpoint|http route)\b/i },
+  { key: "frontend", title: "frontend component", pattern: /\b(?:frontend|react component|ui component|user interface)\b/i },
+  { key: "test", title: "test coverage", pattern: /\b(?:test|tests|test suite|coverage)\b/i },
+  { key: "docs", title: "documentation", pattern: /\b(?:documentation|readme|guide|runbook)\b/i },
+  { key: "deploy", title: "deployment pipeline", pattern: /\b(?:deployment|deploy pipeline|ci pipeline|release pipeline)\b/i },
+  { key: "performance", title: "performance", pattern: /\b(?:performance|latency|throughput)\b/i },
+  { key: "security", title: "security controls", pattern: /\b(?:security|vulnerability|secret handling)\b/i },
+  { key: "research", title: "product research", pattern: /\b(?:product discovery|user research|customer research)\b/i },
+  { key: "planning", title: "project plan", pattern: /\b(?:roadmap|project plan|delivery plan)\b/i },
+];
+
+function safeActivityEvidence(notes) {
+  const evidence = [];
+  const seen = new Set();
+  for (const [noteIndex, { turn, note }] of notes.entries()) {
+    let inCodeBlock = false;
+    for (const [lineIndex, rawLine] of note.split("\n").entries()) {
+      if (rawLine.trim().startsWith("```")) { inCodeBlock = !inCodeBlock; continue; }
+      if (inCodeBlock) continue;
+      const line = rawLine.trim().replace(/^[-*]\s+/, "").split(/[.;—]/, 1)[0];
+      const action = WORK_ACTIONS.find((item) => item.pattern.test(line));
+      const object = WORK_OBJECTS.find((item) => item.pattern.test(line));
+      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}` });
+      if (evidence.length === MAX_EVIDENCE_ITEMS) return evidence;
+    }
+  }
+  return evidence;
 }
 
 function payloadForSegment(harness, segment) {
   const { notes } = reviewSegment(harness, segment.sessionRef, segment.fromTurn, segment.toTurn);
-  const fallback = `${HARNESS_NAMES[harness]} activity across turns ${segment.fromTurn}–${segment.toTurn}.`;
-  const evidence = safeActivityEvidence(notes, segment).slice(0, MAX_EVIDENCE_ITEMS);
-  const title = evidence.length === 1 ? evidence[0].title : evidence.length > 1 ? "Multiple harness activities" : fallback;
-  const summary = evidence.length ? `Used ${HARNESS_NAMES[harness]} for ${evidence.map((item) => item.title.toLowerCase()).join(", ")}.` : fallback;
+  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.";
   return {
     harness,
     sessionRef: segment.sessionRef,
     fromTurn: segment.fromTurn,
     toTurn: segment.toTurn,
-    title: conciseTitle(title, fallback),
+    title: conciseTitle(title, "No supported work identified"),
     summary,
     evidence,
     verification: [],
@@ -586,6 +631,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.");
@@ -667,7 +835,12 @@ async function confirm(question) {
 
 async function readSecret(input = process.stdin) {
   const ownsInput = !input.isTTY;
-  if (ownsInput) input = new tty.ReadStream(fs.openSync(process.platform === "win32" ? "CONIN$" : "/dev/tty", "r"));
+  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);
+  }
   const wasRaw = input.isRaw;
   process.stderr.write("Connection key (hidden): ");
   input.setRawMode(true);
@@ -755,11 +928,11 @@ function install(harness, quiet = false) {
       .replaceAll('"codex"', '"opencode"')
       .replaceAll("--harness codex", "--harness opencode")
       .replaceAll("Codex", "OpenCode")
-      .replaceAll("npx @useshifu/coding-harness", `"${process.execPath}" "${installedRunnerPath()}"`);
+      .replaceAll("npx --yes @useshifu/coding-harness", `"${process.execPath}" "${installedRunnerPath()}"`);
     fs.writeFileSync(path.join(skillDest, "SKILL.md"), skillContent, { mode: 0o600 });
 
     const commandContent = fs.readFileSync(path.join(__dirname, "..", "commands", "shifu-sync.md"), "utf8")
-      .replaceAll("npx @useshifu/coding-harness", `"${process.execPath}" "${installedRunnerPath()}"`);
+      .replaceAll("npx --yes @useshifu/coding-harness", `"${process.execPath}" "${installedRunnerPath()}"`);
     for (const folder of ["command", "commands"]) {
       const commandDir = path.join(configDir, "opencode", folder);
       fs.mkdirSync(commandDir, { recursive: true, mode: 0o700 });
@@ -773,14 +946,14 @@ function install(harness, quiet = false) {
       .replaceAll('"codex"', `"${harness}"`)
       .replaceAll("--harness codex", `--harness ${harness}`)
       .replaceAll("Codex", HARNESS_NAMES[harness])
-      .replaceAll("npx @useshifu/coding-harness", `"${process.execPath}" "${installedRunnerPath()}"`);
+      .replaceAll("npx --yes @useshifu/coding-harness", `"${process.execPath}" "${installedRunnerPath()}"`);
     fs.writeFileSync(skill, content, { mode: 0o600 });
   }
   const removedHooks = harness === "codex" && removeCodexHooks();
   if (!quiet) {
     console.error(`Installed the Shifu sync instruction for ${HARNESS_NAMES[harness]}.`);
     if (removedHooks) console.error("Removed obsolete Codex lifecycle hooks.");
-    console.error(`Next: coding-harness connect --harness ${harness}`);
+    console.error(`Next: npx --yes @useshifu/coding-harness connect --harness ${harness}`);
   }
 }
 
@@ -849,6 +1022,45 @@ function installSchedule(harness) {
   return artifact.file;
 }
 
+function removeSchedule(harness) {
+  const artifact = schedulerArtifact(harness, process.env.SHIFU_PLATFORM || process.platform);
+  if (process.env.SHIFU_SKIP_SCHEDULER_ACTIVATION !== "1") {
+    if (process.platform === "darwin") {
+      const domain = `gui/${process.getuid()}`;
+      const label = `com.useshifu.coding-harness.${harness}`;
+      const scheduleIsLoaded = () => {
+        let listing;
+        try { listing = execFileSync("launchctl", ["list"], { encoding: "utf8" }); }
+        catch { throw new Error("Could not check the Shifu schedule. Disconnect was cancelled."); }
+        return listing.split(/\r?\n/).some((line) => line.trim().split(/\s+/).at(-1) === label);
+      };
+      if (scheduleIsLoaded()) {
+        try { execFileSync("launchctl", ["bootout", domain, artifact.file], { stdio: "ignore" }); }
+        catch { throw new Error("Could not stop the Shifu schedule. Disconnect was cancelled."); }
+        if (scheduleIsLoaded()) throw new Error("The Shifu schedule is still running. Disconnect was cancelled.");
+      }
+    } else if (process.platform === "linux") {
+      if (fs.existsSync(artifact.file)) {
+        const timer = `shifu-coding-harness-${harness}.timer`;
+        try { execFileSync("systemctl", ["--user", "disable", "--now", timer], { stdio: "ignore" }); }
+        catch { throw new Error("Could not stop the Shifu schedule. Disconnect was cancelled."); }
+        let state;
+        try { state = execFileSync("systemctl", ["--user", "show", "--property=ActiveState", "--value", timer], { encoding: "utf8" }).trim(); }
+        catch { throw new Error("Could not verify that the Shifu schedule stopped. Disconnect was cancelled."); }
+        if (state === "active" || state === "activating") throw new Error("The Shifu schedule is still running. Disconnect was cancelled.");
+      }
+    } else if (process.platform === "win32") {
+      if (fs.existsSync(artifact.file)) {
+        try { execFileSync("schtasks.exe", ["/Delete", "/TN", `Shifu coding harness ${harness}`, "/F"], { stdio: "ignore" }); }
+        catch { throw new Error("Could not stop the Shifu schedule. Disconnect was cancelled."); }
+      }
+    }
+  }
+  for (const item of [artifact, ...(artifact.extraFiles || [])]) {
+    try { fs.unlinkSync(item.file); } catch (error) { if (error?.code !== "ENOENT") throw error; }
+  }
+}
+
 function scheduleNextRun(harness, intervalHours) {
   const state = readState(harness);
   state.schedule = { ...(state.schedule || {}), nextRunAt: Date.now() + intervalHours * 3_600_000 };
@@ -864,11 +1076,28 @@ async function chooseSyncPolicy(existing) {
   };
 }
 
-async function connect(harness) {
+async function validateConnection(apiUrl, token, harness) {
+  let response;
+  try {
+    response = await fetch(`${apiUrl}/v1/connectors/coding-sessions/connection?harness=${encodeURIComponent(harness)}`, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(10_000),
+    });
+  } catch {
+    throw new Error("Could not reach Shifu to verify the connection key. Nothing was changed.");
+  }
+  if (response.status === 401 || response.status === 422) throw new Error("Shifu rejected this connection key for the selected coding tool. Nothing was changed.");
+  if (!response.ok) throw new Error(`Shifu could not verify the connection key (HTTP ${response.status}). Nothing was changed.`);
+  const result = await response.json().catch(() => null);
+  if (result?.data?.connected !== true) throw new Error("Shifu returned an invalid connection check. Nothing was changed.");
+}
+
+async function connect(harness, readKey = readSecret) {
   const existing = readJSON(configPath(harness), undefined);
-  const token = existing?.token || (await readSecret()).trim();
+  const token = (await readKey()).trim();
   if (!TOKEN_PATTERN.test(token)) throw new Error("The connection key is invalid.");
   const apiUrl = requireSafeApiUrl(option("--api-url") || existing?.apiUrl || process.env.SHIFU_API_URL || DEFAULT_API_URL);
+  await validateConnection(apiUrl, token, harness);
   const savedPolicy = existing && normalizedPolicy(existing);
   const currentPolicy = savedPolicy?.onboardingComplete ? savedPolicy : { intervalHours: DEFAULT_INTERVAL_HOURS, approvalMode: "automatic", excludedSessionRefs: savedPolicy?.excludedSessionRefs || [] };
   const selected = await chooseSyncPolicy(currentPolicy);
@@ -878,6 +1107,11 @@ async function connect(harness) {
   install(harness, true);
   const scheduleFile = installSchedule(harness);
   writeJSON(configPath(harness), { ...existing, version: CONFIG_VERSION, apiUrl, token, harness, syncPolicy, inputFolder });
+  if (existing?.token && existing.token !== token) {
+    for (const file of [statePath(harness), pendingPath(harness)]) {
+      try { fs.unlinkSync(file); } catch (error) { if (error?.code !== "ENOENT") throw error; }
+    }
+  }
   scheduleNextRun(harness, syncPolicy.intervalHours);
   console.error(`${HARNESS_NAMES[harness]} is connected. It will sync every ${syncPolicy.intervalHours} hours with ${syncPolicy.approvalMode} approval.`);
   console.error(`Shifu sync folder: ${inputFolder}. Place .txt, .md, .rtf, or .docx files there. Only grounded contributions will become claims.`);
@@ -885,6 +1119,16 @@ async function connect(harness) {
   console.error(`Schedule installed at ${scheduleFile}. No content was sent during setup.`);
 }
 
+function disconnect(harness) {
+  readConfig(harness);
+  if (fs.existsSync(lockPath(harness))) throw new Error("A Shifu sync is running. Try disconnecting again after it finishes.");
+  removeSchedule(harness);
+  for (const file of [configPath(harness), statePath(harness), pendingPath(harness)]) {
+    try { fs.unlinkSync(file); } catch (error) { if (error?.code !== "ENOENT") throw error; }
+  }
+  console.error(`${HARNESS_NAMES[harness]} is disconnected on this device. Revoke the old key in Shifu if you no longer want it usable.`);
+}
+
 async function updateConfig(harness) {
   const config = readConfig(harness);
   const savedPolicy = normalizedPolicy(config);
@@ -950,6 +1194,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);
@@ -994,6 +1248,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);
@@ -1177,12 +1453,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;
 }
@@ -1337,6 +1617,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");
@@ -1354,19 +1635,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();
@@ -1381,16 +1664,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);
@@ -1476,6 +1761,7 @@ async function main() {
   const harness = requireHarness(option("--harness"));
   if (command === "install") return install(harness);
   if (command === "connect") return connect(harness);
+  if (command === "disconnect") return disconnect(harness);
   if (command === "config" && subCommand === "update") return updateConfig(harness);
   if (command === "sync") return sync(harness);
   if (command === "sync-files") return syncFilesNow(harness);
@@ -1485,7 +1771,7 @@ async function main() {
   if (command === "status") return status(harness);
   if (command === "sessions" || command === "discover" || (command === "session" && (subCommand === "discover" || subCommand === "list" || !subCommand || subCommand.startsWith("-")))) return sessions(harness);
   if (command === "review") return review(harness);
-  throw new Error("Use install, connect, config update, status, sessions, review, sync, sync-files, pending, approve, or scheduled-sync.");
+  throw new Error("Use install, connect, disconnect, config update, status, sessions, review, sync, sync-files, pending, approve, or scheduled-sync.");
 }
 
 if (require.main === module) {
@@ -1497,4 +1783,4 @@ if (require.main === module) {
     });
 }
 
-module.exports = { approvalNotificationInvocation, claudeReview, claudeSession, codexReview, codexSession, configPath, configuredSyncPolicy, defaultInputFolder, finalAssistantNote, install, installDestination, localSessions, normalizedPolicy, notificationSessionRef, opencodeQuery, opencodeReview, opencodeSessions, payloadForSegment, pendingSegments, prepareInputFolder, readSecret, removeHooks, requireSafeApiUrl, reviewCandidates, schedulerArtifact, statePath, syncWorkFiles, textIsSafe, unsyncedCodexSessions, 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

@@ -2,7 +2,7 @@
 description: Inspect or sync redacted OpenCode activity using the saved Shifu policy.
 ---
 
-Run `npx @useshifu/coding-harness status --harness opencode` first.
+Run `npx --yes @useshifu/coding-harness status --harness opencode` first.
 
 For an explicit Shifu input-folder sync, run `sync-files --harness opencode`. It polls unfinished jobs before submitting new or changed `.txt`, `.md`, `.rtf`, and `.docx` files up to 20 MB. Upload starts asynchronous server processing; check status on the next manual or scheduled sync. Only a final `processed`, `no_claims`, or `duplicate` result completes the local checkpoint; a `partial` result remains retryable. Completed file checkpoints from the previous runner are replayed once; existing in-flight jobs are polled before replay. Report published claims and needs-evidence suggestions separately. `no_claims` may still include suggestions, which are not verified user contributions. Unsupported files are counted but not uploaded. No claim-review step is needed. Do not treat another speaker's work or a meeting action item as the user's contribution. The server parses and sanitizes files; the local runner does not redact file contents, and file text or excerpts must not appear in logs.
 
@@ -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 generic `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 is valid when only the safe session summary remains.
+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.
 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.
 
-To connect or finish onboarding, run `connect --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 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>`).

package/package.json

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

package/skills/shifu-sync/SKILL.md

@@ -1,57 +1,63 @@
 ---
 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, names, customer details, or proprietary identifiers in a coding-session payload. 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:
 
 ```sh
-npx @useshifu/coding-harness connect --harness codex
+npx --yes @useshifu/coding-harness connect --harness codex
 ```
 
-`connect` 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. If a connection already exists, `connect` keeps its key, checkpoints, and chosen policy. 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 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.
+
+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.
 
 When the user asks to change the interval, approval mode, or input folder, run:
 
 ```sh
-npx @useshifu/coding-harness config update --harness codex --input-folder <existing-readable-folder>
+npx --yes @useshifu/coding-harness config update --harness codex --input-folder <existing-readable-folder>
 ```
 
 Use only the flags the user wants to change; existing settings are preserved. The CLI validates a custom folder before saving. Do not add a second confirmation around either command.
 
 ## Inspect status or queued work
 
-Run `npx @useshifu/coding-harness status --harness codex` to inspect the saved policy, next scheduled run, pending count, and checkpoints.
+Run `npx --yes @useshifu/coding-harness status --harness codex` to inspect the saved policy, next scheduled run, pending count, and checkpoints.
 
-For an explicit input-folder sync, run `npx @useshifu/coding-harness sync-files --harness codex`. It first polls previously accepted file jobs, then submits new or changed supported files. Uploading starts background processing; it does not wait for extraction. A later manual or scheduled sync polls status again. Only `processed`, `no_claims`, or `duplicate` advances a file's completed checkpoint; `partial` is retried on the next sync. The upgraded runner replays old completed checkpoints once, while preserving and polling in-flight jobs before their replay. No claim review or manual approval is needed for files. Report submitted, processing, retry-needed, unsupported, published-claim, and needs-evidence suggestion counts separately. Do not claim a submitted file was fully processed. If a file fails, leave it pending and report the error. Never print file text, candidate statements, or excerpts into logs.
+For an explicit input-folder sync, run `npx --yes @useshifu/coding-harness sync-files --harness codex`. It first polls previously accepted file jobs, then submits new or changed supported files. Uploading starts background processing; it does not wait for extraction. A later manual or scheduled sync polls status again. Only `processed`, `no_claims`, or `duplicate` advances a file's completed checkpoint; `partial` is retried on the next sync. The upgraded runner replays old completed checkpoints once, while preserving and polling in-flight jobs before their replay. No claim review or manual approval is needed for files. Report submitted, processing, retry-needed, unsupported, published-claim, and needs-evidence suggestion counts separately. Do not claim a submitted file was fully processed. If a file fails, leave it pending and report the error. Never print file text, candidate statements, or excerpts into logs.
 
 The folder runner accepts nonempty `.txt`, `.md`, `.rtf`, and `.docx` files up to 20 MB; the server accepts at most 500,000 extractable characters per file and splits that text into bounded chunks. Empty, malformed, binary, and renamed unsupported files cannot yield claims. A `no_claims` result means processing finished with no published claims; it may still have retained needs-evidence suggestions. Suggestions are possible contributions with unresolved evidence or attribution, not verified claims. If both counts are zero, no attributable contribution was extracted; upload itself may still have succeeded. For a named transcript, confirm the user's Shifu Profile display name matches their speaker label before expecting automated attribution. Never promise a claim from every file or infer one from an action item. The upload has a transport deadline, but model processing has no upload-request timeout; failed chunks back off and can be retried without republishing completed chunks.
 
 In manual mode, scheduled runs accumulate redacted segments locally. Run:
 
 ```sh
-npx @useshifu/coding-harness pending --harness codex
+npx --yes @useshifu/coding-harness pending --harness codex
 ```
 
-Show the returned list and ask for one approval for the whole list. After approval, run `npx @useshifu/coding-harness approve --approved --harness codex`. Do not ask again.
+Show the returned list and ask for one approval for the whole list. After approval, run `npx --yes @useshifu/coding-harness approve --approved --harness codex`. Do not ask again.
 
 ## Sync now
 
 For an explicit sync request, first read `status` to determine the saved approval mode. Use the time window the user names; otherwise use 24 hours. Supported interactive windows are 24, 48, and 72 hours.
 
-1. Run `npx @useshifu/coding-harness sessions --harness codex --hours <24|48|72>`.
+1. Run `npx --yes @useshifu/coding-harness sessions --harness codex --hours <24|48|72>`.
 2. Ignore `blockedSessions` unless the user specifically selects one. For a selected older backlog, add `--session-ref <sessionRef> --all`.
-3. For each returned segment, run `npx @useshifu/coding-harness review --harness codex --session-ref <sessionRef> --hours <24|48|72>`.
+3. For each returned segment, run `npx --yes @useshifu/coding-harness review --harness codex --session-ref <sessionRef> --hours <24|48|72>`.
 4. Prepare a version-four payload from the returned final-assistant notes. Keep the returned `sessionRef`, `fromTurn`, and `toTurn` unchanged.
 5. In automatic mode, send it without another approval. In manual mode, show the exact payload and ask once; after approval, pass `--approved` to the sync command.
 6. Repeat discovery after accepted segments until the selected window is exhausted.
@@ -76,13 +82,13 @@ Use `kind: "activity"` for general harness work; it does not require a technical
 Automatic mode:
 
 ```sh
-printf '%s' '<redacted JSON>' | npx @useshifu/coding-harness sync --harness codex
+printf '%s' '<redacted JSON>' | npx --yes @useshifu/coding-harness sync --harness codex
 ```
 
 Manual mode, only after the user's single approval:
 
 ```sh
-printf '%s' '<redacted JSON>' | npx @useshifu/coding-harness sync --approved --harness codex
+printf '%s' '<redacted JSON>' | npx --yes @useshifu/coding-harness sync --approved --harness codex
 ```
 
 If a transport or server error remains after the runner's retries, report that the checkpoint was not advanced. Do not alter the segment or skip ahead.