@aiwg/cli 2026.9.4 → 2026.9.5

package/dist/src/dataset/fortemi-dataset-execution.js

@@ -0,0 +1,158 @@
+import { canonicalFortemiDatasetJson, fortemiDatasetDigest, verifyFortemiDatasetRunReceipt } from "./fortemi-run-receipt.js";
+export const FORTEMI_DATASET_EXECUTION_TOOL = "manage_dataset_execution";
+export function fortemiDatasetRequestDigest(request) {
+    return fortemiDatasetDigest({
+        contractVersions: request.contractVersions || {},
+        schemaVersions: request.schemaVersions || {},
+        negotiation: request.negotiation || {},
+        plan: request.plan,
+        batch: request.batch,
+        resourceEnvelope: request.resourceEnvelope,
+        profiles: request.profiles || {},
+        inputSchemaDigest: request.inputSchemaDigest,
+        outputSchemaDigest: request.outputSchemaDigest,
+    });
+}
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("CONFORMANCE_FORTEMI_RESPONSE_INVALID");
+    return value;
+}
+/** MCP transport binding; receipt verification is implemented independently in AIWG. */
+export class FortemiDatasetExecutionClient {
+    client;
+    runs = new Map();
+    constructor(client) {
+        this.client = client;
+    }
+    async call(action, parameters = {}) {
+        const response = object(await this.client.callTool(FORTEMI_DATASET_EXECUTION_TOOL, { ...parameters, action }));
+        if (response.isError === true)
+            throw new Error("CONFORMANCE_FORTEMI_TOOL_FAILED");
+        if (Array.isArray(response.content)) {
+            const blocks = response.content.map(object);
+            if (blocks.length !== 1 || blocks[0].type !== "text" || typeof blocks[0].text !== "string")
+                throw new Error("CONFORMANCE_FORTEMI_RESPONSE_INVALID");
+            return object(JSON.parse(blocks[0].text));
+        }
+        return response;
+    }
+    async capabilities() {
+        const result = await this.call("capabilities");
+        if (object(result.contracts).receipt !== "fortemi.dataset-run-receipt/v1"
+            || object(result.schemaVersions).receipt !== "1.0.0"
+            || object(result.receiptValidation).revision !== "1.0.1"
+            || object(result.receiptValidation).requestBindingRevision !== "1.0.1")
+            throw new Error("CONFORMANCE_FORTEMI_RECEIPT_REVISION_UNSUPPORTED");
+        return result;
+    }
+    async preview(request) {
+        await this.capabilities();
+        const result = await this.call("preview", { request });
+        if (result.noSideEffects !== true)
+            throw new Error("CONFORMANCE_FORTEMI_PREVIEW_INVALID");
+        if (result.accepted === true && result.requestDigest !== fortemiDatasetRequestDigest(request))
+            throw new Error("CONFORMANCE_FORTEMI_PREVIEW_BINDING_MISMATCH");
+        return result;
+    }
+    /** The caller must approve the exact digest returned by read-only preview. */
+    async execute(request, approvedRequestDigest) {
+        request = structuredClone(request);
+        if (!/^sha256:[a-f0-9]{64}$/.test(approvedRequestDigest))
+            throw new Error("CONFORMANCE_LIVE_AUTHORIZATION_REQUIRED");
+        if (fortemiDatasetRequestDigest(request) !== approvedRequestDigest)
+            throw new Error("CONFORMANCE_FORTEMI_PLAN_NOT_APPROVED");
+        const preview = await this.preview(request);
+        if (preview.accepted !== true || preview.requestDigest !== approvedRequestDigest)
+            throw new Error("CONFORMANCE_FORTEMI_PLAN_NOT_APPROVED");
+        if (typeof request.runId !== "string")
+            throw new Error("CONFORMANCE_FORTEMI_RUN_INVALID");
+        const previous = this.runs.get(request.runId);
+        if (previous && previous.digest !== approvedRequestDigest)
+            throw new Error("CONFORMANCE_FORTEMI_PLAN_NOT_APPROVED");
+        this.runs.set(request.runId, { request: structuredClone(request), digest: approvedRequestDigest });
+        const result = await this.call("execute", { request });
+        return this.verifyResult(result, request, approvedRequestDigest);
+    }
+    verifyResult(result, request, approvedRequestDigest) {
+        const errors = verifyFortemiDatasetRunReceipt(result.receipt);
+        if (errors.length)
+            throw new Error(`CONFORMANCE_FORTEMI_RECEIPT_INVALID:${errors.join(",")}`);
+        const receipt = result.receipt;
+        if (receipt.requestDigest !== approvedRequestDigest || receipt.runId !== request.runId
+            || receipt.namespaceId !== object(object(request.plan).destination).dataset
+            || receipt.state !== result.state || receipt.verification !== result.verification)
+            throw new Error("CONFORMANCE_FORTEMI_RECEIPT_BINDING_MISMATCH");
+        const plan = object(request.plan);
+        const batch = object(request.batch);
+        if (["planId", "sourceRevision", "mode", "planDigest", "configurationDigest", "transformationDigest"].some(key => receipt.bindings[key] !== plan[key])
+            || receipt.bindings.inputSchemaDigest !== request.inputSchemaDigest || receipt.bindings.outputSchemaDigest !== request.outputSchemaDigest
+            || receipt.bindings.inputDigest !== fortemiDatasetDigest(batch.mutations)
+            || receipt.idempotencyKey !== (batch.idempotencyKey || approvedRequestDigest)
+            || canonicalFortemiDatasetJson(receipt.resourceEnvelope) !== canonicalFortemiDatasetJson(request.resourceEnvelope)
+            || canonicalFortemiDatasetJson(receipt.profiles) !== canonicalFortemiDatasetJson(request.profiles || {})
+            || canonicalFortemiDatasetJson(receipt.checkpoint.after) !== canonicalFortemiDatasetJson(batch.checkpointAfter)
+            || canonicalFortemiDatasetJson(receipt.checkpoint.before || null) !== canonicalFortemiDatasetJson(batch.checkpointBefore || null))
+            throw new Error("CONFORMANCE_FORTEMI_RECEIPT_BINDING_MISMATCH");
+        return receipt;
+    }
+    knownRun(runId) {
+        const run = this.runs.get(runId);
+        if (!run)
+            throw new Error("CONFORMANCE_FORTEMI_RUN_UNKNOWN");
+        return run;
+    }
+    async retry(runId, action = "retry") {
+        const run = this.knownRun(runId);
+        return this.verifyResult(await this.call(action, { runId }), run.request, run.digest);
+    }
+    async status(runId) {
+        const run = this.knownRun(runId);
+        const result = await this.call("status", { runId });
+        if (result.runId !== runId)
+            throw new Error("CONFORMANCE_FORTEMI_RECEIPT_BINDING_MISMATCH");
+        if (result.receipt)
+            this.verifyResult(result, run.request, run.digest);
+        else if (result.state !== "running" || result.verification !== "pending")
+            throw new Error("CONFORMANCE_FORTEMI_RESPONSE_INVALID");
+        return result;
+    }
+    async checkpoint(runId) {
+        this.knownRun(runId);
+        const result = await this.call("checkpoint", { runId });
+        if (result.runId !== runId || (result.checkpoint !== undefined && !["committed", "degraded"].includes(String(result.state))))
+            throw new Error("CONFORMANCE_FORTEMI_CHECKPOINT_UNVERIFIED");
+        if (result.checkpoint !== undefined) {
+            const status = await this.status(runId);
+            const receipt = status.receipt;
+            if (result.receiptDigest !== receipt.receiptDigest || canonicalFortemiDatasetJson(result.checkpoint) !== canonicalFortemiDatasetJson(receipt.checkpoint.after))
+                throw new Error("CONFORMANCE_FORTEMI_CHECKPOINT_UNVERIFIED");
+        }
+        return result;
+    }
+    async cancel(runId) {
+        this.knownRun(runId);
+        const result = await this.call("cancel", { runId });
+        if (result.runId !== runId)
+            throw new Error("CONFORMANCE_FORTEMI_RECEIPT_BINDING_MISMATCH");
+        return result;
+    }
+    async archive(runId) {
+        const run = this.knownRun(runId);
+        const status = await this.status(runId);
+        const receipt = status.receipt;
+        if (!receipt || !["committed", "degraded", "failed"].includes(receipt.state))
+            throw new Error("CONFORMANCE_FORTEMI_ARCHIVE_UNRESOLVED");
+        const result = await this.call("archive", { runId });
+        if (result.namespaceId !== object(object(run.request.plan).destination).dataset
+            || typeof result.complete !== "boolean" || !Array.isArray(result.unresolved)
+            || result.unresolved.some(value => typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value))
+            || (result.complete && result.unresolved.length !== 0)
+            || !Number.isSafeInteger(result.archived) || Number(result.archived) < 0
+            || !Number.isSafeInteger(result.alreadyArchived) || Number(result.alreadyArchived) < 0
+            || Number(result.archived) + Number(result.alreadyArchived) + result.unresolved.length !== receipt.counts.committed)
+            throw new Error("CONFORMANCE_FORTEMI_ARCHIVE_INVALID");
+        return result;
+    }
+}
+//# sourceMappingURL=fortemi-dataset-execution.js.map

package/dist/src/dataset/fortemi-live-qualification.d.ts

@@ -1,9 +1,10 @@
 import type { McpClientLike } from "../storage/backends/fortemi.js";
-export declare const FORTEMI_DATASET_LIVE_CONTRACT: "aiwg.fortemi-dataset-live-qualification/v1";
+export declare const FORTEMI_DATASET_LIVE_CONTRACT: "aiwg.fortemi-dataset-live-qualification/v2";
+declare const LEGACY_LIVE_CONTRACT: "aiwg.fortemi-dataset-live-qualification/v1";
 export declare const FORTEMI_DATASET_CAPABILITIES_TOOL = "dataset_capabilities";
 export declare const FORTEMI_DATASET_EXECUTE_TOOL = "dataset_execute";
 export interface FortemiDatasetLiveReceipt {
-    contract: typeof FORTEMI_DATASET_LIVE_CONTRACT;
+    contract: typeof FORTEMI_DATASET_LIVE_CONTRACT | typeof LEGACY_LIVE_CONTRACT;
     outcome: "pending" | "supported";
     diagnostic: "CONFORMANCE_FORTEMI_DATASET_CONTRACT_UNAVAILABLE" | "CONFORMANCE_FORTEMI_DATASET_PREFLIGHT_SUPPORTED";
     receiptDigest: string;
@@ -50,4 +51,5 @@ export declare function qualifyFortemiDatasetLivePreflight(input: {
 export declare function verifyFortemiDatasetLiveReceipt(value: unknown): string[];
 /** Atomically creates private evidence without replacing an existing receipt. */
 export declare function writeFortemiDatasetLiveReceipt(path: string, receipt: FortemiDatasetLiveReceipt): Promise<void>;
+export {};
 //# sourceMappingURL=fortemi-live-qualification.d.ts.map

package/dist/src/dataset/fortemi-live-qualification.js

@@ -1,18 +1,22 @@
 import { randomUUID } from "node:crypto";
 import { link, mkdir, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+import { FORTEMI_DATASET_EXECUTION_TOOL } from "./fortemi-dataset-execution.js";
 import { endpointFingerprint, fortemiReceiptDigest, } from "../storage/fortemi-qualification-receipt.js";
-export const FORTEMI_DATASET_LIVE_CONTRACT = "aiwg.fortemi-dataset-live-qualification/v1";
+export const FORTEMI_DATASET_LIVE_CONTRACT = "aiwg.fortemi-dataset-live-qualification/v2";
+const LEGACY_LIVE_CONTRACT = "aiwg.fortemi-dataset-live-qualification/v1";
 export const FORTEMI_DATASET_CAPABILITIES_TOOL = "dataset_capabilities";
 export const FORTEMI_DATASET_EXECUTE_TOOL = "dataset_execute";
 const UUID_NAMESPACE = /^aiwg-dataset-qualification-[0-9a-f-]{36}$/u;
 const COMMIT = /^[0-9a-f]{40}$/u;
 const DIGEST = /^sha256:[0-9a-f]{64}$/u;
 const SAFE = /^[A-Za-z0-9._:/-]+$/u;
-const REQUIRED_TOOLS = [
+const LEGACY_TOOLS = [
     FORTEMI_DATASET_CAPABILITIES_TOOL,
     FORTEMI_DATASET_EXECUTE_TOOL,
 ];
+const REQUIRED_TOOLS = [FORTEMI_DATASET_EXECUTION_TOOL];
+const REQUIRED_ACTIONS = ["capabilities", "preview", "execute", "status", "checkpoint", "cancel", "resume", "retry", "verify", "archive"];
 const MAX_TOOL_COUNT = 256;
 const MAX_SCHEMA_BYTES = 1_048_576;
 function record(value) {
@@ -81,24 +85,18 @@ export async function qualifyFortemiDatasetLivePreflight(input) {
             observedSchemaBytes > MAX_SCHEMA_BYTES)
             throw new Error("CONFORMANCE_RESOURCE_ENVELOPE_EXCEEDED");
         const tools = new Map(inventory.map((tool) => [tool.name, tool]));
-        const specifications = [
-            {
-                tool: FORTEMI_DATASET_CAPABILITIES_TOOL,
-                required: { contract_version: "string" },
-            },
-            {
-                tool: FORTEMI_DATASET_EXECUTE_TOOL,
-                required: {
-                    contract_version: "string",
-                    namespace: "string",
-                    plan: "object",
-                    records: "array",
-                },
-            },
-        ];
+        const specifications = [{ tool: FORTEMI_DATASET_EXECUTION_TOOL, required: { action: "string" } }];
         const checks = specifications.map(({ tool, required }) => {
             const unique = inventory.filter((candidate) => candidate.name === tool).length === 1;
-            const compatible = unique && inputSchemaCompatible(tools.get(tool)?.inputSchema, required);
+            const compatible = unique && inputSchemaCompatible(tools.get(tool)?.inputSchema, required)
+                && (() => {
+                    const properties = record(record(tools.get(tool)?.inputSchema)?.properties);
+                    const actions = record(properties?.action)?.enum;
+                    return Array.isArray(actions) && REQUIRED_ACTIONS.every(action => actions.includes(action))
+                        && record(properties?.request)?.type === "object"
+                        && record(properties?.runId)?.type === "string"
+                        && record(properties?.receipt)?.type === "object";
+                })();
             return {
                 tool,
                 compatible,
@@ -211,7 +209,7 @@ export function verifyFortemiDatasetLiveReceipt(value) {
             "code",
         ])))
         errors.push("CONFORMANCE_RECEIPT_SHAPE_INVALID");
-    if (receipt.contract !== FORTEMI_DATASET_LIVE_CONTRACT)
+    if (receipt.contract !== FORTEMI_DATASET_LIVE_CONTRACT && receipt.contract !== LEGACY_LIVE_CONTRACT)
         errors.push("CONFORMANCE_RECEIPT_CONTRACT_MISMATCH");
     if (!COMMIT.test(receipt.bindings.aiwgCommit) ||
         !DIGEST.test(receipt.bindings.endpointFingerprint) ||
@@ -231,8 +229,9 @@ export function verifyFortemiDatasetLiveReceipt(value) {
         receipt.resources.networkAttempts !== 1)
         errors.push("CONFORMANCE_RECEIPT_MUTATION_INVALID");
     const operationNames = receipt.operations.map((operation) => operation.tool);
-    const inventoryValid = receipt.operations.length === REQUIRED_TOOLS.length &&
-        REQUIRED_TOOLS.every((tool) => operationNames.filter((name) => name === tool).length === 1);
+    const requiredTools = receipt.contract === LEGACY_LIVE_CONTRACT ? LEGACY_TOOLS : REQUIRED_TOOLS;
+    const inventoryValid = receipt.operations.length === requiredTools.length &&
+        requiredTools.every((tool) => operationNames.filter((name) => name === tool).length === 1);
     if (!inventoryValid ||
         receipt.operations.some((operation) => operation.code !==
             (operation.compatible

package/dist/src/dataset/fortemi-run-receipt.d.ts

@@ -0,0 +1,44 @@
+/** Independent implementation of the Fortemi wire canonicalization contract. */
+export declare function canonicalFortemiDatasetJson(value: unknown): string;
+export declare function fortemiDatasetDigest(value: unknown): string;
+interface Checkpoint {
+    sequence: number;
+    scope: {
+        dataset: string;
+        [key: string]: string;
+    };
+}
+export interface FortemiDatasetRunReceipt {
+    receiptDigest: string;
+    requestDigest: string;
+    runId: string;
+    idempotencyKey: string;
+    profiles: unknown;
+    namespaceId: string;
+    bindings: Record<string, string>;
+    effects: Array<{
+        outcome: "committed" | "conflict" | "rejected" | "unverifiable";
+    }>;
+    counts: {
+        attempted: number;
+        committed: number;
+        rejected: number;
+    };
+    checkpoint: {
+        before?: Checkpoint;
+        after: Checkpoint;
+    };
+    capabilityDecision: {
+        selected: string[];
+        degradations: unknown[];
+    };
+    resourceEnvelope: {
+        maxRecords: number;
+    };
+    state: "running" | "committed" | "degraded" | "failed" | "cancelled" | "ambiguous";
+    verification: "pending" | "verified" | "failed" | "unverifiable";
+}
+/** Schema validity, semantic consistency, and checksum integrity; not issuer authentication. */
+export declare function verifyFortemiDatasetRunReceipt(value: unknown): string[];
+export {};
+//# sourceMappingURL=fortemi-run-receipt.d.ts.map

package/dist/src/dataset/fortemi-run-receipt.js

@@ -0,0 +1,74 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+/** Independent implementation of the Fortemi wire canonicalization contract. */
+export function canonicalFortemiDatasetJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number" && Number.isFinite(value))
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalFortemiDatasetJson).join(",")}]`;
+    if (typeof value === "object") {
+        const object = value;
+        return `{${Object.keys(object).sort().map(key => `${JSON.stringify(key)}:${canonicalFortemiDatasetJson(object[key])}`).join(",")}}`;
+    }
+    throw new Error("RECEIPT_VALUE_INVALID");
+}
+export function fortemiDatasetDigest(value) {
+    return `sha256:${createHash("sha256").update(canonicalFortemiDatasetJson(value), "utf8").digest("hex")}`;
+}
+function schemaPath() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        try {
+            const metadata = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+            if (metadata.name === "aiwg" || metadata.name === "@aiwg/cli") {
+                return join(directory, "schemas/dataset/fortemi-run-receipt/validation-1.0.1/run-receipt.schema.json");
+            }
+        }
+        catch { /* Source and built installations have different depths. */ }
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error("FORTEMI_RECEIPT_SCHEMA_UNAVAILABLE");
+        directory = parent;
+    }
+}
+const ajv = new Ajv2020({ strict: true, allErrors: true });
+addFormats(ajv);
+const validate = ajv.compile(JSON.parse(readFileSync(schemaPath(), "utf8")));
+/** Schema validity, semantic consistency, and checksum integrity; not issuer authentication. */
+export function verifyFortemiDatasetRunReceipt(value) {
+    if (!validate(value))
+        return ["RECEIPT_STRUCTURE_INVALID"];
+    const receipt = value;
+    const errors = [];
+    const { receiptDigest, ...payload } = receipt;
+    if (fortemiDatasetDigest(payload) !== receiptDigest)
+        errors.push("RECEIPT_DIGEST_MISMATCH");
+    const { attempted, committed, rejected } = receipt.counts;
+    if (committed + rejected !== attempted)
+        errors.push("RECEIPT_COUNTS_INCONSISTENT");
+    const committedEffects = receipt.effects.filter(effect => effect.outcome === "committed").length;
+    if (receipt.effects.length !== attempted || committedEffects !== committed || attempted - committedEffects !== rejected)
+        errors.push("RECEIPT_EFFECTS_INCONSISTENT");
+    if (receipt.state === "failed" && committed !== 0)
+        errors.push("RECEIPT_STATE_INCONSISTENT");
+    if (receipt.bindings.outputDigest !== fortemiDatasetDigest(receipt.effects)
+        || receipt.bindings.resourceEnvelopeDigest !== fortemiDatasetDigest(receipt.resourceEnvelope)
+        || receipt.bindings.negotiationDigest !== fortemiDatasetDigest({ selected: receipt.capabilityDecision.selected, degradations: receipt.capabilityDecision.degradations, diagnostics: [] }))
+        errors.push("RECEIPT_BINDINGS_INCONSISTENT");
+    const { before, after } = receipt.checkpoint;
+    if (after.scope.dataset !== receipt.namespaceId || receipt.bindings.destinationDigest !== fortemiDatasetDigest(after.scope)
+        || (before && (canonicalFortemiDatasetJson(before.scope) !== canonicalFortemiDatasetJson(after.scope) || before.sequence >= after.sequence)))
+        errors.push("RECEIPT_CHECKPOINT_INCONSISTENT");
+    if (attempted > receipt.resourceEnvelope.maxRecords)
+        errors.push("RECEIPT_RESOURCE_LIMIT_EXCEEDED");
+    return errors;
+}
+//# sourceMappingURL=fortemi-run-receipt.js.map

package/dist/src/dataset/index.d.ts

@@ -15,6 +15,8 @@ export * from './file-orchestration-repository.js';
 export * from './local-execution-backend.js';
 export * from './fortemi-execution-bridge.js';
 export * from './fortemi-live-qualification.js';
+export * from './fortemi-run-receipt.js';
+export * from './fortemi-dataset-execution.js';
 export * from './orchestration-service.js';
 export * from './presentation.js';
 export * from './conformance-types.js';

package/dist/src/dataset/index.js

@@ -15,6 +15,8 @@ export * from './file-orchestration-repository.js';
 export * from './local-execution-backend.js';
 export * from './fortemi-execution-bridge.js';
 export * from './fortemi-live-qualification.js';
+export * from './fortemi-run-receipt.js';
+export * from './fortemi-dataset-execution.js';
 export * from './orchestration-service.js';
 export * from './presentation.js';
 export * from './conformance-types.js';

package/dist/src/extensions/commands/definitions.js

@@ -1079,6 +1079,28 @@ export const sessionCommand = {
         },
     },
 };
+export const writingCommand = {
+    id: 'writing', type: 'command', name: 'Writing',
+    description: 'Prepare grounded writing plans and apply authorized proofreading corrections with canonical receipts',
+    version: '1.0.0', capabilities: ['cli', 'voice', 'writing', 'proofread'],
+    keywords: ['writing', 'brief', 'proofread', 'author', 'receipt'],
+    category: 'project', platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: { type: 'command', template: 'utility', argumentHint: '<plan|proofread> --brief <file> --profile <id> [--output <new-file>]', allowedTools: ['Read', 'Write', 'Bash'] },
+};
+export const writerProfileCommand = {
+    id: 'writer-profile', type: 'command', name: 'Writer Profiles',
+    description: 'Import, inspect, export, version, compile, revoke, and delete author-controlled writer sidecars',
+    version: '1.0.0', capabilities: ['cli', 'voice', 'writer-profile'],
+    keywords: ['writer-profile', 'author', 'voice', 'sample', 'provenance'],
+    category: 'project', platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: {
+        type: 'command', template: 'utility',
+        argumentHint: '<list|import|inspect|export|version|compile|revoke|delete> [id] [--scope project|user]',
+        allowedTools: ['Read', 'Write', 'Bash'],
+    },
+};
 export const outputModeCommand = {
     id: 'output-mode',
     type: 'command',
@@ -3801,6 +3823,8 @@ export const commandDefinitions = [
     sessionCommand,
     sessionsCommand,
     outputModeCommand,
+    writerProfileCommand,
+    writingCommand,
     schemaCommand,
     datasetCommand,
 ];

package/dist/src/extensions/manifest.js

@@ -119,11 +119,14 @@ export const ProviderConfigSchema = z.object({
         'codex',
         'copilot',
         'cursor',
+        'deepseek-harness',
         'factory',
         'hermes',
         'opencode',
         'openclaw',
         'openhuman',
+        'omp',
+        'pi',
         'warp',
         'windsurf',
     ]),

package/dist/src/mcp/server.mjs

@@ -18,6 +18,7 @@ import { z } from 'zod';
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { registerWriterProfileResources } from './tools/writer-profiles.mjs';
 import { registerDiscoveryTools } from './tools/discovery.mjs';
 import { registerCommandRunTool } from './tools/command-run.mjs';
 import { registerInteractionTools } from './tools/interaction.mjs';
@@ -51,6 +52,7 @@ export function createServer() {
   //   rule-list, rule-show, agent-show, template-list, template-show
   // ============================================
   registerDiscoveryTools(server);
+  registerWriterProfileResources(server);
 
   // ============================================
   // Command-run dispatch (#1312) — registers:

package/dist/src/mcp/tools/writer-profiles.mjs

@@ -0,0 +1,40 @@
+import { access } from 'node:fs/promises';
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { findProjectRoot } from '../helpers.mjs';
+
+async function builtModule(name) {
+  for (const location of [new URL(`../../writing/${name}.js`, import.meta.url), new URL(`../../../dist/src/writing/${name}.js`, import.meta.url)]) {
+    try { await access(location); } catch { continue; }
+    return import(location.href);
+  }
+  throw new Error('Writer profile resources require the built CLI package.');
+}
+
+/** Scope-bound metadata listing; explicit reads always use the shared export policy. */
+export function registerWriterProfileResources(server, options = {}) {
+  const projectRoot = () => options.projectRoot ? Promise.resolve(options.projectRoot) : findProjectRoot();
+  const api = options.loadApi ?? (async () => ({ ...await builtModule('writer-profile'), ...await builtModule('writer-profile-store') }));
+  server.registerResource('writer-profiles', 'aiwg://writer-profiles/catalog', {
+    title: 'Writer Profile Catalog', description: 'Scoped writer profile identifiers and revisions; excludes raw samples.', mimeType: 'application/json',
+  }, async () => {
+    const cwd = await projectRoot(); const { WriterProfileStore, inspectWriterProfile } = await api();
+    const profiles = [];
+    for (const scope of ['project', 'user']) {
+      const store = new WriterProfileStore({ cwd, scope });
+      for (const id of await store.list()) {
+        const metadata = inspectWriterProfile(await store.read(id));
+        profiles.push({ scope, ...metadata, uri: `aiwg://writer-profiles/${scope}/${encodeURIComponent(id)}` });
+      }
+    }
+    return { contents: [{ uri: 'aiwg://writer-profiles/catalog', mimeType: 'application/json', text: JSON.stringify({ profiles, providerInterception: false }) }] };
+  });
+  server.registerResource('writer-profile', new ResourceTemplate('aiwg://writer-profiles/{scope}/{id}', { list: undefined }), {
+    title: 'Shared Writer Profile', description: 'Explicit scoped read using profile sharing approvals; private exports are unavailable through this resource.', mimeType: 'application/json',
+  }, async (uri, variables) => {
+    const selection = z.object({ scope: z.enum(['project', 'user']), id: z.string().regex(/^[a-z0-9][a-z0-9.-]{0,79}$/) }).strict().parse(variables);
+    const cwd = await projectRoot(); const { WriterProfileStore, exportWriterProfile } = await api();
+    const profile = await new WriterProfileStore({ cwd, scope: selection.scope }).read(selection.id);
+    return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(exportWriterProfile(profile, 'shared')) }] };
+  });
+}

package/dist/src/models/model-capabilities.v1.json

@@ -118,6 +118,17 @@
       "verification": "Inspect strict JSONL state and the selected provider/model",
       "sourceUrl": "https://github.com/earendil-works/pi/tree/main/packages/coding-agent#cli-reference", "verifiedAt": "2026-09-04"
     },
+    "deepseek-harness": {
+      "agent": "native", "skill": "inherited", "globalChild": "native",
+      "identifierSyntax": "provider/model passed through the SDK initialize request or agent-default-model Cordis row",
+      "effortValues": ["minimal", "low", "medium", "high", "xhigh"],
+      "inheritance": "Subagents inherit the configured Harness route unless explicitly overridden",
+      "invalidPinFallback": "Explicit unavailable routes or models fail the request",
+      "configTarget": "Ephemeral Cordis route patch and SDK initialize request",
+      "artifactFormat": "agent-default-model config; JSON-RPC initialize params",
+      "verification": "Pinned source contract plus opt-in headless OpenRouter smoke",
+      "sourceUrl": "https://github.com/deepseek-ai/deepseek-harness", "verifiedAt": "2026-09-05"
+    },
     "windsurf": {
       "agent": "unsupported", "skill": "unsupported", "globalChild": "inherited",
       "identifierSyntax": "UI-selected provider model",

package/dist/src/models/model-catalog.v1.json

@@ -89,6 +89,14 @@
       },
       "sourceUrl": "https://github.com/earendil-works/pi/tree/main/packages/coding-agent#providers--models", "verifiedAt": "2026-09-04"
     },
+    "deepseek-harness": {
+      "roles": {
+        "reasoning": { "id": "configured/reasoning", "status": "unverified", "observed": false },
+        "coding": { "id": "configured/coding", "status": "unverified", "observed": false },
+        "efficiency": { "id": "configured/efficiency", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://github.com/deepseek-ai/deepseek-harness", "verifiedAt": "2026-09-05"
+    },
     "warp": {
       "roles": {
         "reasoning": { "id": "profile-selected", "status": "unverified", "observed": false },

package/dist/src/models/provider-policy.js

@@ -26,7 +26,7 @@ function requireModelResource(filename) {
 const capabilityData = requireModelResource('model-capabilities.v1.json');
 const catalogData = requireModelResource('model-catalog.v1.json');
 const ProviderSchema = z.enum([
-    'antigravity', 'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
+    'antigravity', 'claude', 'codex', 'copilot', 'cursor', 'deepseek-harness', 'factory', 'hermes',
     'opencode', 'openclaw', 'openhuman', 'omp', 'pi', 'warp', 'windsurf',
 ]);
 const OutcomeSchema = z.enum([