@useshifu/coding-harness 0.3.5 → 0.3.6

package/README.md

@@ -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

@@ -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) {
@@ -622,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.");
@@ -1062,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);
@@ -1106,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);
@@ -1289,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;
 }
@@ -1449,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");
@@ -1466,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();
@@ -1493,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);
@@ -1610,4 +1783,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useshifu/coding-harness",
-  "version": "0.3.5",
+  "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,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, 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: