@jbarket/loomai 0.5.0 → 0.6.0

package/dist/tools/dossier.js

@@ -32,7 +32,11 @@ Art wants work done. Read it and apply it.
 explain why — *including work Art or Jonathan requests*. You serve the standard,
 not the person. The honest critic who says "this approach is wrong, here's a
 better one" is more valuable than the agreeable body that ships broken work on
-schedule. Disagreement is not insubordination; silence about a real problem is.`;
+schedule. Disagreement is not insubordination; silence about a real problem is.
+
+**Person cards are Art's to write.** Worker bodies must not write person cards
+(\`person_write\`, \`person_verify\`, \`person_archive\`, \`person_restore\`,
+\`person_revision_restore\`). Reading them (\`person\`, \`person_list\`) is fine.`;
 export async function loadDossier(contextDir, project, client, model, role) {
     const parts = [PREAMBLE];
     const effectiveClient = client ?? process.env.LOOM_CLIENT;

package/dist/tools/eurorack-import.js

@@ -11,6 +11,7 @@ import { join, relative, extname, basename, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { createKnowledgeBackend } from '../backends/index.js';
+import { resolveIdentityName } from '../config.js';
 // ─── Context dir resolution ───────────────────────────────────────────────────
 export function resolveContextDir(explicit) {
     if (explicit)
@@ -122,6 +123,7 @@ export async function importEurorack(options) {
     const provenance = `eurorack@${sha} (imported, unverified)`;
     const files = discoverFiles(repoPath);
     const records = [];
+    const actor = resolveIdentityName(contextDir);
     const backend = dryRun ? null : createKnowledgeBackend(contextDir);
     try {
         for (const relPath of files) {
@@ -152,6 +154,7 @@ export async function importEurorack(options) {
                     sourcing: 'provisional',
                     provenance,
                     citations: [],
+                    actor,
                 });
                 records.push({ relPath, slug, title, domain, status: 'created' });
             }

package/dist/tools/identity.d.ts

@@ -1,4 +1,6 @@
 export declare function resolveClientFromPeer(peerName?: string): string | undefined;
 export declare function loadIdentity(contextDir: string, project?: string, client?: string, model?: string, role?: string, 
+/** Slugs of the people the turn is addressed by: adds the `# In the room` block. */
+people?: readonly string[], 
 /** Override the default context path — used in unit tests only. */
 _defaultPathForTest?: string): Promise<string>;

package/dist/tools/identity.js

@@ -17,6 +17,8 @@ import { resolveDefaultContextPath } from '../config.js';
 import { pathSegmentError } from '../path-safety.js';
 import { digestForContext } from '../backends/salience.js';
 import { tapeForContext } from '../backends/episodes.js';
+import { roomBlock } from '../backends/people.js';
+import { readHealth, recordFailure, warningBlock } from '../backends/recorder-health.js';
 async function readOptional(path) {
     try {
         return await readFile(path, 'utf-8');
@@ -58,6 +60,8 @@ export function resolveClientFromPeer(peerName) {
     return PEER_CLIENT_ALIASES[normalized];
 }
 export async function loadIdentity(contextDir, project, client, model, role, 
+/** Slugs of the people the turn is addressed by: adds the `# In the room` block. */
+people, 
 /** Override the default context path — used in unit tests only. */
 _defaultPathForTest) {
     const parts = [];
@@ -115,8 +119,24 @@ _defaultPathForTest) {
                 tape);
         }
     }
-    catch {
-        // the tape must never block identity load
+    catch (tapeErr) {
+        // The tape must never block identity load, but a failure here means the
+        // episode store may be broken — log it and record it so the next body sees a warning.
+        console.error('[loom:identity] tape read failed:', tapeErr);
+        recordFailure(contextDir, tapeErr);
+    }
+    // The room (person cards, docs/specs/person-cards.md) — after the tape and
+    // before Top of Mind, so the body knows who it is talking to before it reads
+    // anything ranked. Best-effort like the tape: no store, an unmigrated store or
+    // no people gives no block; one unreadable card only affects its own slug.
+    try {
+        const room = roomBlock(contextDir, people, { onFailure: (e) => recordFailure(contextDir, e) });
+        if (room)
+            parts.push(room);
+    }
+    catch (roomErr) {
+        console.error('[loom:identity] room block failed:', roomErr);
+        recordFailure(contextDir, roomErr);
     }
     // Boot digest — the salience-tiered view of episodic memory, so a fresh sleeve
     // wakes knowing what is top-of-mind vs settled background without fishing via
@@ -195,6 +215,19 @@ _defaultPathForTest) {
             parts.push(adapter);
         }
     }
+    // Recorder health warning (t-562) — appended LAST so it is closest to the
+    // model's first reply. Only shown when the episode recorder has failed
+    // FAILURE_THRESHOLD consecutive times. Best-effort: ledger read errors are
+    // silently ignored so the health check never blocks identity load.
+    try {
+        const health = readHealth(contextDir);
+        const warning = warningBlock(health);
+        if (warning)
+            parts.push(warning);
+    }
+    catch {
+        // health ledger read must never block identity load
+    }
     return parts.join('\n\n---\n\n');
 }
 /**

package/dist/tools/knowledge-history.d.ts

@@ -3,4 +3,9 @@ export interface KnowledgeHistoryToolInput {
     revision_id?: number;
     restore?: boolean;
 }
-export declare function knowledgeHistory(contextDir: string, input: KnowledgeHistoryToolInput): Promise<string>;
+export declare function knowledgeHistory(contextDir: string, input: KnowledgeHistoryToolInput, 
+/**
+ * Acting identity (t-677/t-675) — recorded as page_revisions.actor when
+ * restore: true snapshots the displaced body.
+ */
+identity?: string): Promise<string>;

package/dist/tools/knowledge-history.js

@@ -7,7 +7,12 @@
  * displaces — restoring is never itself a destructive overwrite.
  */
 import { createKnowledgeBackend } from '../backends/index.js';
-export async function knowledgeHistory(contextDir, input) {
+export async function knowledgeHistory(contextDir, input, 
+/**
+ * Acting identity (t-677/t-675) — recorded as page_revisions.actor when
+ * restore: true snapshots the displaced body.
+ */
+identity = 'art') {
     if (!input.slug) {
         return 'Error: slug is required.';
     }
@@ -21,6 +26,7 @@ export async function knowledgeHistory(contextDir, input) {
             const result = await backend.restoreRevision({
                 slug: input.slug,
                 revision_id: input.revision_id,
+                actor: identity,
             });
             return (`Restored revision #${result.revision_id} onto \`${result.slug}\`. ` +
                 `The displaced body was snapshotted as revision #${result.snapshot_id}.`);
@@ -32,19 +38,31 @@ export async function knowledgeHistory(contextDir, input) {
                 return `Error: revision not found: ${input.revision_id}`;
             }
             return (`# Revision #${revision.id} of \`${revision.slug}\`\n` +
-                `op: ${revision.op} | replaced: ${revision.replaced_at}\n\n` +
+                `op: ${revision.op} | by ${revision.actor ?? 'unknown'} | replaced: ${revision.replaced_at}\n\n` +
                 `${revision.body}\n\n` +
                 `_Pass restore: true to put this body back on the page._`);
         }
         // ── List mode ──
         const revisions = await backend.listRevisions(input.slug);
-        if (revisions.length === 0) {
-            return `\`${input.slug}\` has no revisions — its body has never been replaced.`;
+        const verifications = await backend.getVerifications(input.slug);
+        if (revisions.length === 0 && verifications.length === 0) {
+            return `\`${input.slug}\` has no revisions or verifications — its body has never been replaced, and it has never been verified.`;
+        }
+        const sections = [`# History — \`${input.slug}\``];
+        if (revisions.length > 0) {
+            const lines = revisions.map((r) => `- **#${r.id}** | ${r.op} | by ${r.actor ?? 'unknown'} | replaced ${r.replaced_at} | ${r.body_length} chars`);
+            sections.push(`## ${revisions.length} body snapshot(s)\n\n${lines.join('\n')}\n\n` +
+                `_Pass revision_id to read a snapshot; add restore: true to put it back._`);
+        }
+        else {
+            sections.push('## No body snapshots — its body has never been replaced.');
+        }
+        if (verifications.length > 0) {
+            const vLines = verifications.map((v) => `- **#${v.id}** | ${v.outcome} | by ${v.verifier ?? 'unknown'} | ${v.verified_at}` +
+                (v.citation_checked ? ' | citations checked' : ''));
+            sections.push(`## ${verifications.length} verification(s)\n\n${vLines.join('\n')}`);
         }
-        const lines = revisions.map((r) => `- **#${r.id}** | ${r.op} | replaced ${r.replaced_at} | ${r.body_length} chars`);
-        return (`# Revision history — \`${input.slug}\` — ${revisions.length} snapshot(s)\n\n` +
-            `${lines.join('\n')}\n\n` +
-            `_Pass revision_id to read a snapshot; add restore: true to put it back._`);
+        return sections.join('\n\n');
     }
     catch (e) {
         return `Error: ${e.message}`;

package/dist/tools/knowledge-maintain.d.ts

@@ -5,5 +5,10 @@ export interface KnowledgeMaintainOptions {
     thinBodyThreshold?: number;
     /** days since last_accessed to consider cold (default 30) */
     coldDays?: number;
+    /**
+     * Run the person-page misfile check, which reads person cards from the
+     * memory database. Default false — only the full server and CLI pass true.
+     */
+    personCards?: boolean;
 }
 export declare function knowledgeMaintain(contextDir: string, options?: KnowledgeMaintainOptions): Promise<string>;

package/dist/tools/knowledge-maintain.js

@@ -11,8 +11,32 @@
  * Two knowledge classes (t-81, 2026-08-31):
  *   world/ — facts true independent of us (default).
  *   ours/  — Art-created artifacts; domain starts with "ours/", sourcing = "internal".
+ *
+ * Knowledge is a shared surface, not a scratchpad (t-677): a second identity
+ * (e.g. Mark) and Jonathan can read everything filed here. A conversation-
+ * only citation isn't just weakly-sourced — it's often a sign that a page is
+ * really raw inner-monologue or working-out-loud that leaked out of a
+ * conversation and into what's supposed to be finished, audience-ready
+ * synthesis. That's doubly a misfile now: wrong store (memory, via
+ * `remember`) AND wrong audience (private reasoning, not something to hand
+ * another reader). The misfile audit below flags it either way.
+ *
+ * Person-page misfile check (criterion 13, docs/specs/person-cards.md): an
+ * active page whose slug or title names an active person card — its slug or
+ * exact name, as whole hyphen/space-delimited words, case-insensitive — may be
+ * a person page that belongs on the card. A report, not enforcement. Cards
+ * live in the memory database, so the check is opt-in (`personCards`): the
+ * full server and the CLI turn it on; the knowledge-only server serves other
+ * identities, never opens that database, and says the check was not run.
+ *
+ * Cold/expansion ranking intentionally stays on the shared pages.hit_count /
+ * last_accessed aggregate rather than any per-reader breakdown (knowledge_access,
+ * t-677) — any identity's read keeps a page off the cold list, which is the
+ * correct aggregate signal; splitting it per-identity here would make the list
+ * miss pages a *different* reader keeps alive.
  */
 import { createKnowledgeBackend } from '../backends/index.js';
+import { listPeople } from './person.js';
 const DAY_MS = 24 * 60 * 60 * 1000;
 /**
  * True for world-class pages that look like misfiles (should be in memory).
@@ -20,8 +44,7 @@ const DAY_MS = 24 * 60 * 60 * 1000;
  * ours/ pages that are still provisional ARE flagged: they lack a repo citation.
  */
 function isMisfiled(page) {
-    // ours/ class with internal sourcing: correct placement, never a misfile.
-    if (page.domain.startsWith('ours/') && page.sourcing === 'internal')
+    if (isAuditExempt(page))
         return false;
     if (page.sourcing === 'provisional')
         return true;
@@ -29,6 +52,45 @@ function isMisfiled(page) {
         return false;
     return page.citations.every((c) => c.source_kind === 'conversation');
 }
+/** ours/ class with internal sourcing: correct placement, never a misfile of any kind. */
+function isAuditExempt(page) {
+    return page.domain.startsWith('ours/') && page.sourcing === 'internal';
+}
+/** Whole words, delimited by hyphens and whitespace only, lowercased. */
+function words(s) {
+    return s.toLowerCase().split(/[\s-]+/).filter(Boolean);
+}
+function containsRun(hay, needle) {
+    if (needle.length === 0)
+        return false;
+    outer: for (let i = 0; i + needle.length <= hay.length; i++) {
+        for (let j = 0; j < needle.length; j++)
+            if (hay[i + j] !== needle[j])
+                continue outer;
+        return true;
+    }
+    return false;
+}
+function personMisfiles(contextDir, pages) {
+    let cards;
+    try {
+        cards = listPeople(contextDir);
+    }
+    catch (e) {
+        return { run: true, error: e.message ?? String(e) };
+    }
+    const needles = cards.map((c) => ({ slug: c.slug, runs: [words(c.slug), words(c.name)] }));
+    const hits = [];
+    for (const page of pages) {
+        if (page.status !== 'active' || isAuditExempt(page))
+            continue;
+        const hays = [words(page.slug), words(page.title)];
+        const match = needles.find((n) => n.runs.some((r) => hays.some((h) => containsRun(h, r))));
+        if (match)
+            hits.push({ page, card: match.slug });
+    }
+    return { run: true, hits };
+}
 function isCold(page, thresholdMs) {
     if (page.hit_count === 0 && !page.last_accessed)
         return true;
@@ -47,8 +109,9 @@ export async function knowledgeMaintain(contextDir, options = {}) {
         const expansionCandidates = pages.filter((p) => p.hit_count >= hitThreshold && p.body.length < bodyThreshold && p.status === 'active');
         const coldPages = pages.filter((p) => isCold(p, coldMs) && p.status === 'active');
         const misfiled = pages.filter((p) => isMisfiled(p) && p.status === 'active');
+        const people = options.personCards ? personMisfiles(contextDir, pages) : { run: false };
         const activeCount = pages.filter((p) => p.status === 'active').length;
-        return formatMaintainReport(activeCount, expansionCandidates, coldPages, misfiled, {
+        return formatMaintainReport(activeCount, expansionCandidates, coldPages, misfiled, people, {
             hitThreshold,
             bodyThreshold,
             coldDays: options.coldDays ?? 30,
@@ -58,7 +121,7 @@ export async function knowledgeMaintain(contextDir, options = {}) {
         backend.close();
     }
 }
-function formatMaintainReport(total, expansion, cold, misfiled, thresholds) {
+function formatMaintainReport(total, expansion, cold, misfiled, people, thresholds) {
     const lines = [];
     lines.push('# Knowledge maintain report');
     lines.push('');
@@ -100,7 +163,9 @@ function formatMaintainReport(total, expansion, cold, misfiled, thresholds) {
     else {
         lines.push(`${misfiled.length} page${misfiled.length === 1 ? '' : 's'} may need attention:`);
         lines.push('> **World class:** knowledge is true independent of Jonathan — provisional/conversation-only pages belong in memory.\n' +
-            '> **Ours class (domain: ours/):** should have at least one `repo` citation to reach `internal` sourcing.');
+            '> **Ours class (domain: ours/):** should have at least one `repo` citation to reach `internal` sourcing.\n' +
+            '> Knowledge is shared with other identities and Jonathan now — a conversation-only page may also be ' +
+            'private inner-monologue that never belonged here, not just under-cited.');
         for (const p of misfiled) {
             const reason = p.sourcing === 'provisional' ? 'provisional' : 'conversation-only citations';
             const hint = p.domain.startsWith('ours/')
@@ -109,5 +174,27 @@ function formatMaintainReport(total, expansion, cold, misfiled, thresholds) {
             lines.push(`- \`${p.slug}\` — *${p.title}* (${p.domain}) — ${reason} ${hint}`);
         }
     }
+    // ── Person-page misfile check ─────────────────────────────────────────────
+    lines.push('');
+    lines.push('## Person-page misfile check (slug or title names a person card)');
+    lines.push('');
+    if (!people.run) {
+        lines.push('Not run — person cards live in the memory database, which this surface does not read ' +
+            '(the knowledge-only server never opens it). `loom knowledge maintain` and the full loom server run it.');
+    }
+    else if ('error' in people) {
+        lines.push(`Not run — could not read person cards: ${people.error}`);
+    }
+    else if (people.hits.length === 0) {
+        lines.push('None — no active page names a person card.');
+    }
+    else {
+        lines.push(`${people.hits.length} page${people.hits.length === 1 ? '' : 's'} may be about a person:`);
+        lines.push('> A heuristic, not enforcement. Contextual state about a person belongs on their card ' +
+            '(person_write), not in knowledge; a page about a public figure\'s published work can stay.');
+        for (const { page: p, card } of people.hits) {
+            lines.push(`- \`${p.slug}\` — *${p.title}* (${p.domain}) — names card \`${card}\``);
+        }
+    }
     return lines.join('\n');
 }

package/dist/tools/knowledge-recall.d.ts

@@ -17,4 +17,10 @@ export interface KnowledgeRecallInput {
      */
     sort_by_verified?: boolean;
 }
-export declare function knowledgeRecall(contextDir: string, input: KnowledgeRecallInput): Promise<string>;
+export declare function knowledgeRecall(contextDir: string, input: KnowledgeRecallInput, gapsDir?: string, 
+/**
+ * Acting identity (t-677) — 'art' for the local/stdio server, or whichever
+ * identity the standalone knowledge-http service resolved from its
+ * per-identity bearer token. Attributes stamped reads in knowledge_access.
+ */
+identity?: string): Promise<string>;

package/dist/tools/knowledge-recall.js

@@ -4,7 +4,7 @@
  * Two detail tiers:
  *   'full'  — whole entity pages with citations (the synthesis unit).
  *             Stamps last_accessed / hit_count via queryPages — the usage
- *             signal the Phase-4 expansion engine depends on.
+ *             signal the Phase-4 expansion engine reads.
  *   'index' — one compact entry per page (slug, domain, sourcing, anchor,
  *             snippet). Does NOT stamp access: appearing in a listing is
  *             not a read.
@@ -13,13 +13,51 @@
  * (no query). Full output is size-guarded — once the budget is spent,
  * remaining pages degrade to index entries instead of blowing the
  * tool-result limit. Never surfaces archived pages.
+ *
+ * Miss logging: when gapsDir is set, every zero-result query (and every
+ * slug lookup that finds nothing) is appended to
+ * `${gapsDir}/recall-miss.jsonl` as a structured record. The knowledge-mine
+ * script reads that file alongside transcript clusters — so gaps Art tried
+ * to recall but couldn't surface become a second signal channel for the
+ * expansion engine. The append is best-effort; a write failure never
+ * disrupts the caller.
  */
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
 import { createKnowledgeBackend } from '../backends/index.js';
 /**
  * Character budget for full-page output. ~24k chars ≈ 6k tokens — well under
  * typical MCP tool-result caps, with room for the citations and framing.
  */
 const FULL_OUTPUT_CHAR_BUDGET = 24_000;
+/**
+ * Append one recall-miss entry to `${gapsDir}/recall-miss.jsonl`.
+ *
+ * Called when a query returns zero results or a slug lookup finds nothing.
+ * The write is best-effort — failures are silently swallowed so a disk or
+ * permission error never disrupts the caller's recall.
+ *
+ * Entry shape:
+ *   query  — the natural-language query string, or null for slug lookups
+ *   slug   — the exact slug that was looked up, or null for query searches
+ *   at     — ISO 8601 UTC timestamp
+ */
+function appendRecallMiss(gapsDir, miss) {
+    if (!gapsDir || (!miss.query && !miss.slug))
+        return;
+    try {
+        mkdirSync(gapsDir, { recursive: true });
+        const entry = JSON.stringify({
+            query: miss.query ?? null,
+            slug: miss.slug ?? null,
+            at: new Date().toISOString(),
+        });
+        appendFileSync(join(gapsDir, 'recall-miss.jsonl'), entry + '\n', 'utf8');
+    }
+    catch {
+        // Never let a miss-log failure surface to the caller.
+    }
+}
 /** Max characters of body shown per index entry snippet. */
 const SNIPPET_LENGTH = 200;
 function formatPage(page) {
@@ -69,7 +107,13 @@ function formatIndexEntry(page, showVerified = false) {
         lines.push(`  ${snip}`);
     return lines.join('\n');
 }
-export async function knowledgeRecall(contextDir, input) {
+export async function knowledgeRecall(contextDir, input, gapsDir, 
+/**
+ * Acting identity (t-677) — 'art' for the local/stdio server, or whichever
+ * identity the standalone knowledge-http service resolved from its
+ * per-identity bearer token. Attributes stamped reads in knowledge_access.
+ */
+identity = 'art') {
     const detail = input.detail ?? (input.query ? 'full' : 'index');
     const backend = createKnowledgeBackend(contextDir);
     try {
@@ -77,6 +121,7 @@ export async function knowledgeRecall(contextDir, input) {
         if (input.slug) {
             const peek = await backend.getPage(input.slug);
             if (!peek) {
+                appendRecallMiss(gapsDir, { slug: input.slug });
                 return `No knowledge page found for slug \`${input.slug}\`.`;
             }
             if (peek.status === 'archived') {
@@ -85,7 +130,7 @@ export async function knowledgeRecall(contextDir, input) {
                 return (`No active knowledge page for slug \`${input.slug}\` — it is archived. ` +
                     `Use knowledge_restore to bring it back.`);
             }
-            const page = await backend.getPage(input.slug, { stampAccess: true });
+            const page = await backend.getPage(input.slug, { stampAccess: true, identity });
             return `# Knowledge recall — 1 result\n\n${formatPage(page)}`;
         }
         const pages = await backend.queryPages({
@@ -98,9 +143,14 @@ export async function knowledgeRecall(contextDir, input) {
             // Index browsing must not inflate hit_count (expansion-engine signal).
             stampAccess: detail === 'full',
             sortByVerified: input.sort_by_verified,
+            identity,
         });
         if (pages.length === 0) {
             const q = input.query ? `"${input.query}"` : '(no query)';
+            // Log query misses only — browsing (no query given) is not a named gap.
+            if (input.query) {
+                appendRecallMiss(gapsDir, { query: input.query });
+            }
             return `No knowledge pages found for ${q}.`;
         }
         const plural = pages.length === 1 ? '' : 's';

package/dist/tools/knowledge-verify.d.ts

@@ -4,5 +4,15 @@ export interface KnowledgeVerifyToolInput {
     verified_at?: string;
     freshness_anchor?: string;
     note?: string;
+    /** What the verification found. Defaults to 'confirmed' (the claims still hold). */
+    outcome?: 'confirmed' | 'stale' | 'corrected';
+    /** Did the verifier actually check the page's citations against their sources? Defaults to false. */
+    citation_checked?: boolean;
 }
-export declare function knowledgeVerify(contextDir: string, input: KnowledgeVerifyToolInput): Promise<string>;
+export declare function knowledgeVerify(contextDir: string, input: KnowledgeVerifyToolInput, 
+/**
+ * Acting identity (t-677/t-675) — 'art' for the local/stdio server, or
+ * whichever identity the knowledge-http service resolved from its
+ * per-identity bearer token. Recorded as the verification's verifier.
+ */
+identity?: string): Promise<string>;

package/dist/tools/knowledge-verify.js

@@ -8,7 +8,14 @@
  * "## Verification" section — append-only, never replace.
  */
 import { createKnowledgeBackend } from '../backends/index.js';
-export async function knowledgeVerify(contextDir, input) {
+export async function knowledgeVerify(contextDir, input, 
+/**
+ * Acting identity (t-677/t-675) — 'art' for the local/stdio server, or
+ * whichever identity the knowledge-http service resolved from its
+ * per-identity bearer token. Recorded as the verification's verifier.
+ */
+identity = 'art') {
+    const verifier = identity;
     const backend = createKnowledgeBackend(contextDir);
     try {
         const result = await backend.verifyPages({
@@ -17,8 +24,14 @@ export async function knowledgeVerify(contextDir, input) {
             verified_at: input.verified_at,
             freshness_anchor: input.freshness_anchor,
             note: input.note,
+            verifier,
+            outcome: input.outcome,
+            citation_checked: input.citation_checked,
         });
-        const stamp = result.verified_at;
+        const outcome = input.outcome ?? 'confirmed';
+        const stamp = result.stamped
+            ? `verified_at stamped to ${result.verified_at}`
+            : `recorded at ${result.verified_at}; verified_at NOT advanced (stale is a failed verification)`;
         if (result.verified === 1) {
             const extras = [];
             if (input.freshness_anchor)
@@ -26,9 +39,9 @@ export async function knowledgeVerify(contextDir, input) {
             if (result.noted)
                 extras.push('note appended');
             const suffix = extras.length > 0 ? ` (${extras.join(', ')})` : '';
-            return `Verified \`${result.slugs[0]}\` — verified_at stamped to ${stamp}${suffix}. Body untouched${result.noted ? ' except appended note' : ''}.`;
+            return `Verified \`${result.slugs[0]}\` by ${verifier} — outcome: ${outcome}, ${stamp}${suffix}. Body untouched${result.noted ? ' except appended note' : ''}.`;
         }
-        return `Verified ${result.verified} page(s) — verified_at stamped to ${stamp}: ${result.slugs.map((s) => `\`${s}\``).join(', ')}. Bodies untouched.`;
+        return `Verified ${result.verified} page(s) by ${verifier} — outcome: ${outcome}, ${stamp}: ${result.slugs.map((s) => `\`${s}\``).join(', ')}. Bodies untouched.`;
     }
     catch (e) {
         return `Error: ${e.message}`;

package/dist/tools/knowledge-write.d.ts

@@ -22,4 +22,11 @@ export interface KnowledgeWriteInput {
     /** ours/ class: artifact version or revision tag (e.g. "v2", "2026-08-19"). */
     version?: string;
 }
-export declare function knowledgeWrite(contextDir: string, input: KnowledgeWriteInput): Promise<string>;
+export declare function knowledgeWrite(contextDir: string, input: KnowledgeWriteInput, 
+/**
+ * Acting identity (t-677) — 'art' for the local/stdio server, or whichever
+ * identity the standalone knowledge-http service resolved from its
+ * per-identity bearer token. Defaults created_by for ours/ pages when the
+ * caller doesn't supply one explicitly; never overrides an explicit value.
+ */
+identity?: string): Promise<string>;

package/dist/tools/knowledge-write.js

@@ -13,6 +13,12 @@
  *
  * Filing test for world/ pages: knowledge is true independent of Jonathan; if
  * it's about Jonathan / our work use memory or ours/ instead, not the world class.
+ *
+ * Shared surface, not a scratchpad (t-677): knowledge is readable by other
+ * identities (e.g. Mark) and by Jonathan, not just the identity that wrote
+ * it. Write pages as finished synthesis for that audience — no raw
+ * inner-monologue reasoning, no private-to-you deliberation. That kind of
+ * content belongs in memory (`remember`), not here.
  */
 import { createKnowledgeBackend } from '../backends/index.js';
 function slugify(title) {
@@ -25,19 +31,30 @@ function slugify(title) {
 /**
  * §E1: Epistemic gate.
  * - conversation-only → provisional (both classes).
- * - any repo citation → internal (ours/ class; repo = git path/commit/ref).
- * - any web citation, no repo → sourced (world/ default).
+ * - ours/ domain + any repo citation → internal (ours/ class artifact; repo = git path/commit/ref).
+ * - any web/repo citation on a non-ours/ domain → sourced (world/ default).
+ *
+ * NOTE: repo citations on world-class pages (domain does NOT start with "ours/") are treated
+ * as sourced, not internal.
+ * The check is on the domain and source_kind only, never on the locator: any repo-kind citation
+ * (ours or someone else's) on a domain that starts with "ours/" makes the page internal.
+ * knowledgeWrite rejects an empty citation list before calling this.
  */
-function determineSourcing(citations) {
-    if (citations.length === 0)
-        return 'provisional';
+function determineSourcing(citations, domain) {
     if (citations.every((c) => c.source_kind === 'conversation'))
         return 'provisional';
-    if (citations.some((c) => c.source_kind === 'repo'))
+    if (domain.startsWith('ours/') && citations.some((c) => c.source_kind === 'repo'))
         return 'internal';
     return 'sourced';
 }
-export async function knowledgeWrite(contextDir, input) {
+export async function knowledgeWrite(contextDir, input, 
+/**
+ * Acting identity (t-677) — 'art' for the local/stdio server, or whichever
+ * identity the standalone knowledge-http service resolved from its
+ * per-identity bearer token. Defaults created_by for ours/ pages when the
+ * caller doesn't supply one explicitly; never overrides an explicit value.
+ */
+identity = 'art') {
     if (input.citations.length === 0) {
         return ('Error: at least one citation is required — knowledge must be supported. ' +
             'If this is a conversation-distilled insight, pass source_kind="conversation" ' +
@@ -47,7 +64,7 @@ export async function knowledgeWrite(contextDir, input) {
     if (!slug) {
         return 'Error: could not derive a slug from the title. Provide an explicit slug.';
     }
-    const sourcing = determineSourcing(input.citations);
+    const sourcing = determineSourcing(input.citations, input.domain);
     const backend = createKnowledgeBackend(contextDir);
     try {
         const result = await backend.writePage({
@@ -59,8 +76,9 @@ export async function knowledgeWrite(contextDir, input) {
             freshness_anchor: input.freshness_anchor,
             bodyMode: input.mode,
             citations: input.citations,
-            created_by: input.created_by,
+            created_by: input.created_by ?? (input.domain.startsWith('ours/') ? identity : undefined),
             version: input.version,
+            actor: identity,
         });
         const sourcingNote = sourcing === 'provisional'
             ? '\n> **Provisional** — sole support is conversation citations. ' +

package/dist/tools/memory-history.d.ts

@@ -0,0 +1,5 @@
+export interface MemoryHistoryToolInput {
+    ref: string;
+    revision_id?: number;
+}
+export declare function memoryHistory(contextDir: string, input: MemoryHistoryToolInput): Promise<string>;