@aiwg/cli 2026.9.4 → 2026.9.6

package/dist/src/output-modes/runtime.js

@@ -1,30 +1,101 @@
+import { assessWritingFidelity } from '../writing/fidelity.js';
+import { parseWritingBrief } from '../writing/writing-brief.js';
 function protectedPattern(classes) {
     const set = new Set(classes);
     const alternatives = [];
-    if (set.has('machine-readable-blocks') || set.has('code'))
-        alternatives.push('```[\\s\\S]*?```');
+    if (set.has('machine-readable-blocks') || set.has('code')) {
+        alternatives.push('^ {0,3}(?<backtickFence>`{3,})[^\\n]*\\n[\\s\\S]*?(?:^ {0,3}\\k<backtickFence>`*[ \\t]*$|(?![\\s\\S]))');
+        alternatives.push('^ {0,3}(?<tildeFence>~{3,})[^\\n]*\\n[\\s\\S]*?(?:^ {0,3}\\k<tildeFence>~*[ \\t]*$|(?![\\s\\S]))');
+    }
     if (set.has('code') || set.has('commands'))
-        alternatives.push('`[^`\\n]+`');
+        alternatives.push('(?<!`)(?<ticks>`+)(?!`)[\\s\\S]*?(?<!`)\\k<ticks>(?!`)');
     if (set.has('quoted-text'))
-        alternatives.push('^>.*(?:\\n>.*)*', '“[^”]*”', '"[^"\\n]+"');
+        alternatives.push('^ {0,3}>.*(?:\\n {0,3}>.*)*', '“[^”]*”', '"[^"\\n]+"');
     if (set.has('citations'))
         alternatives.push('\\[[^\\]\\n]+\\]\\([^\\s)]+\\)', '\\[[0-9]+\\]');
     if (set.has('identifiers'))
         alternatives.push('\\b(?:[A-Za-z_$][\\w$]*\\.)+[A-Za-z_$][\\w$]*\\b', '\\b[A-Z][A-Z0-9_]{2,}\\b');
     return alternatives.length ? new RegExp(alternatives.join('|'), 'gm') : null;
 }
-function protect(content, classes) {
+function markdownLinkRanges(content) {
+    const ranges = [];
+    for (let start = 0; start < content.length; start++) {
+        if (content[start] !== '[' || content[start - 1] === '\\')
+            continue;
+        let at = start + 1, brackets = 1;
+        for (; at < content.length && brackets; at++) {
+            if (content[at] === '\\') {
+                at++;
+                continue;
+            }
+            if (content[at] === '[')
+                brackets++;
+            if (content[at] === ']')
+                brackets--;
+        }
+        if (brackets || content[at] !== '(')
+            continue;
+        let depth = 1;
+        let quote = '';
+        for (at++; at < content.length && depth; at++) {
+            const char = content[at];
+            if (char === '\\') {
+                at++;
+                continue;
+            }
+            if (quote) {
+                if (char === quote)
+                    quote = '';
+                continue;
+            }
+            if ((char === '"' || char === "'") && /\s/.test(content[at - 1])) {
+                quote = char;
+                continue;
+            }
+            if (char === '(')
+                depth++;
+            if (char === ')')
+                depth--;
+        }
+        if (!depth) {
+            ranges.push({ start, end: at });
+            start = at - 1;
+        }
+    }
+    return ranges;
+}
+function protect(content, classes, explicitLiterals) {
     const literals = [];
     const pattern = protectedPattern(classes);
+    const ranges = pattern ? [...content.matchAll(pattern)].map(m => ({ start: m.index, end: m.index + m[0].length })) : [];
+    if (classes.includes('citations'))
+        ranges.push(...markdownLinkRanges(content));
+    for (const literal of explicitLiterals) {
+        for (let start = content.indexOf(literal); start !== -1; start = content.indexOf(literal, start + 1)) {
+            ranges.push({ start, end: start + literal.length });
+        }
+    }
+    ranges.sort((a, b) => a.start - b.start || b.end - a.end);
+    const merged = [];
+    for (const range of ranges) {
+        const last = merged.at(-1);
+        if (last && range.start < last.end)
+            last.end = Math.max(last.end, range.end);
+        else
+            merged.push({ ...range });
+    }
     let tokenPrefix = '\uE000AIWG_OUTPUT_MODE_';
     while (content.includes(tokenPrefix))
         tokenPrefix += '_';
-    const protectedContent = pattern ? content.replace(pattern, value => {
+    let protectedContent = '';
+    let cursor = 0;
+    for (const range of merged) {
         const token = `${tokenPrefix}${literals.length}\uE001`;
-        literals.push({ token, value });
-        return token;
-    }) : content;
-    return { content: protectedContent, literals };
+        literals.push({ token, value: content.slice(range.start, range.end) });
+        protectedContent += content.slice(cursor, range.start) + token;
+        cursor = range.end;
+    }
+    return { content: protectedContent + content.slice(cursor), literals };
 }
 function restore(content, literals, mode) {
     let restored = content;
@@ -32,35 +103,100 @@ function restore(content, literals, mode) {
         const occurrences = restored.split(literal.token).length - 1;
         if (occurrences !== 1)
             throw new Error(`Output mode '${mode}' modified, removed, or duplicated a protected literal.`);
-        restored = restored.replace(literal.token, literal.value);
+        restored = restored.replace(literal.token, () => literal.value);
     }
+    if (literals.length && restored.includes(literals[0].token.slice(0, -2)))
+        throw new Error(`Output mode '${mode}' introduced an invalid protected literal token.`);
     return restored;
 }
+async function bounded(action, milliseconds) {
+    let timer;
+    try {
+        return await Promise.race([Promise.resolve().then(action), new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error('Output validation timed out.')), milliseconds);
+            })]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export async function applyOutputModes(input, modes, options) {
-    if (modes.length === 0)
+    if (options.protectedLiterals !== undefined && (!Array.isArray(options.protectedLiterals) || options.protectedLiterals.some(value => typeof value !== 'string' || !value.trim() || /[\uD800-\uDFFF]/u.test(value))))
+        throw new Error('Protected literals must be nonempty well-formed strings.');
+    const protectedLiterals = [...new Set(options.protectedLiterals ?? [])];
+    options = { ...options, ...(options.fidelity ? { fidelity: { brief: parseWritingBrief(options.fidelity.brief) } } : {}) };
+    if (modes.length === 0 && !options.requireFinalValidator && !options.fidelity && !options.validateFinal)
         return { content: input, diagnostics: [], applied: [], fallback: 'none' };
+    const activeModes = structuredClone(modes).filter(mode => mode.id !== 'unaltered');
+    const brief = options.fidelity ? parseWritingBrief(options.fidelity.brief) : undefined;
     let content = input;
     const diagnostics = [];
+    const attempted = [];
     const applied = [];
-    for (const mode of modes) {
-        const masked = protect(content, mode.protectedContent ?? []);
-        const transformed = await options.transform(masked.content, mode);
-        if (typeof transformed !== 'string')
-            throw new Error(`Output mode '${mode.id}' transform returned a non-string result.`);
-        content = restore(transformed, masked.literals, mode.id);
-        if (mode.validation.level !== 'advisory') {
+    const timeout = options.validationTimeoutMs ?? 30_000;
+    if (!Number.isFinite(timeout) || timeout <= 0 || timeout > 300_000)
+        throw new Error('Invalid output validation timeout.');
+    // Earlier stage protection remains mandatory through later presentation passes.
+    const protectedClasses = [...new Set(activeModes.flatMap(mode => mode.protectedContent ?? []))];
+    let fidelity;
+    let currentMode = 'final';
+    let level = 'validated';
+    try {
+        for (const mode of activeModes) {
+            currentMode = mode.id;
+            level = mode.validation.level;
+            attempted.push(mode.id);
+            const masked = protect(content, protectedClasses, protectedLiterals);
+            const transformed = await options.transform(masked.content, structuredClone(mode));
+            if (typeof transformed !== 'string')
+                throw new Error('Output transform returned a non-string result.');
+            content = restore(transformed, masked.literals, mode.id);
+            if (mode.validation.level !== 'advisory') {
+                if (!options.validate)
+                    throw new Error('Mandatory output validator is missing.');
+                const result = await bounded(() => options.validate(content, structuredClone(mode)), timeout);
+                if (result?.valid !== true) {
+                    diagnostics.push({ mode: mode.id, level: mode.validation.level, message: result?.message ?? 'Mandatory output validation did not pass.' });
+                    throw new Error('Mandatory output validation did not pass.');
+                }
+            }
+            applied.push(mode.id);
+        }
+        currentMode = 'final';
+        level = 'validated';
+        // Recheck every mandatory stage against final prose, including structure/presentation changes.
+        for (const mode of activeModes.filter(mode => mode.validation.level !== 'advisory')) {
             if (!options.validate)
-                throw new Error(`Output mode '${mode.id}' declares ${mode.validation.level} validation but no validator is configured.`);
-            const result = await options.validate(content, mode);
-            if (!result.valid) {
-                diagnostics.push({ mode: mode.id, level: mode.validation.level, message: result.message ?? 'validation failed' });
-                if ((options.onMandatoryValidationFailure ?? 'unaltered') === 'fail')
-                    throw new Error(`Output mode '${mode.id}' validation failed: ${result.message ?? 'no diagnostic'}`);
-                return { content: input, diagnostics, applied, fallback: 'unaltered' };
+                throw new Error('Mandatory output validator is missing.');
+            const result = await bounded(() => options.validate(content, structuredClone(mode)), timeout);
+            if (result?.valid !== true) {
+                diagnostics.push({ mode: mode.id, level: mode.validation.level, message: result?.message ?? 'Mandatory validation of final output did not pass.' });
+                throw new Error('Mandatory validation of final output did not pass.');
             }
         }
-        applied.push(mode.id);
+        if (brief) {
+            fidelity = assessWritingFidelity(input, content, brief);
+            if (fidelity.outcome === 'fail')
+                throw new Error('Final fidelity guards detected a material change.');
+        }
+        if (options.requireFinalValidator && !options.validateFinal)
+            throw new Error('Required final validator is missing.');
+        if (options.validateFinal) {
+            const final = await bounded(() => options.validateFinal(input, content, fidelity ? structuredClone(fidelity) : undefined), timeout);
+            if (final?.outcome !== 'pass')
+                throw new Error('Final semantic validation failed or requires review.');
+        }
+        else if (fidelity?.outcome === 'uncertain')
+            throw new Error('Changed prose requires semantic review.');
+        return { content, diagnostics, applied, attempted, retained: [...applied], fallback: 'none', ...(fidelity ? { fidelity } : {}) };
+    }
+    catch (error) {
+        if (!diagnostics.length)
+            diagnostics.push({ mode: currentMode, level, message: error instanceof Error && /^(Output mode|Output validation|Mandatory|Required final|Final |Changed prose)/.test(error.message) ? error.message : 'Output transformation or validation failed.' });
+        if (options.onMandatoryValidationFailure === 'fail' || (options.onMandatoryValidationFailure === undefined && error instanceof Error && error.message.includes('protected literal')))
+            throw error;
+        return { content: input, diagnostics, applied: [], attempted, retained: [], fallback: 'unaltered', ...(fidelity ? { fidelity } : {}) };
     }
-    return { content, diagnostics, applied, fallback: 'none' };
 }
 //# sourceMappingURL=runtime.js.map

package/dist/src/providers/capability-matrix.yaml

@@ -370,7 +370,7 @@ providers:
       # bridge. The "MCP:" entries below are the optional enrichment path, not a
       # requirement. Broader MCP modernization: #1533.
       agents: AGENTS.md
-      commands: "AGENTS.md bridge + aiwg discover/show (MCP command-run optional)"
+      commands: "Indexed: aiwg discover / aiwg show command (MCP command-run optional)"
       skills: "~/.hermes/skills/"
       skills_cross_agent: "~/.hermes/skills/.aiwg/"
       rules: "AGENTS.md ### Rule sections + aiwg show rule (MCP rule-list/rule-show optional)"
@@ -442,8 +442,8 @@ providers:
     daemon_tier: unsupported
     daemon_pty_adapter: false
     artifact_paths:
-      agents: ".agents/agents/"                          # markdown personas (workspace-scoped — the coding hosts OpenHuman drives); harness TOML is Tier-2 (#1559)
-      commands: "AGENTS.md bridge (no native command surface)"
+      agents: "Indexed: aiwg discover / aiwg show agent"   # native TOML harness agents are opt-in (#1559)
+      commands: "Indexed: aiwg discover / aiwg show command"
       skills: "~/.openhuman/skills/"                      # global/home-dir like OpenClaw — ungated user-scope native scan (ops_discover.rs); same root OpenHuman's own installer writes to (#1553)
       skills_cross_agent: "~/.openhuman/.aiwg/skills/"
       rules: "AGENTS.md ### Rule sections + aiwg show rule"
@@ -515,6 +515,48 @@ providers:
     deploy_target: project
     aggregated_output: false
 
+  deepseek-harness:
+    display_name: DeepSeek Harness
+    aliases:
+      - dsh
+    status: experimental
+    daemon_tier: unsupported
+    daemon_pty_adapter: false
+    artifact_paths:
+      agents: .agents/skills/
+      commands: null
+      skills: .agents/skills/
+      rules: AGENTS.md
+      behaviors: null
+      cordis_patch: .dsh/aiwg.cordis.patch.yml
+    native_features:
+      cron: false
+      agent_teams: true
+      tasks: true
+      mcp: true
+      behaviors: true
+      mission_control: false
+      daemon: false
+    emulation:
+      cron: external-trigger
+      agent_teams: native
+      tasks: native
+      mcp: native
+      behaviors: null
+      mission_control: aiwg-mc
+      daemon: null
+    hook_wiring:
+      at_link_support: false
+      fallback: full-inject
+      context_file: AGENTS.md
+      max_bytes: 65536
+    interaction:
+      structured_questions: none
+      fallback: markdown
+      notes: Headless and SDK profiles do not expose an interactive question UI.
+    deploy_target: project
+    aggregated_output: false
+
   pi:
     display_name: Pi Coding Agent
     aliases:

package/dist/src/providers/provider-definitions.js

@@ -17,6 +17,7 @@ const ProviderDefinitionSchema = z.object({
         'codex',
         'copilot',
         'cursor',
+        'deepseek-harness',
         'factory',
         'hermes',
         'opencode',
@@ -32,6 +33,13 @@ const ProviderDefinitionSchema = z.object({
     aliases: z.array(z.string().min(1)),
     status: z.enum(['stable', 'experimental', 'deprecated']),
     builtIn: z.boolean(),
+    upstream: z.object({
+        source: z.string().url(),
+        version: z.string().min(1),
+        revision: z.string().regex(/^[0-9a-f]{40}$/),
+        runtime: z.string().min(1),
+        lastVerified: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    }).optional(),
     surfaces: z.object({
         primary: z.string().min(1),
         compatibility: z.array(z.string().min(1)),
@@ -130,6 +138,7 @@ export const PROVIDER_IDS = [
     'codex',
     'copilot',
     'cursor',
+    'deepseek-harness',
     'factory',
     'hermes',
     'opencode',
@@ -178,6 +187,17 @@ const CONTEXT_CONTRACTS = {
         bootstrapTargets: ['AGENTS.md'], maxContextBytes: null, recommendedMaxLines: 500, nestedContext: false, support: 'supported',
         verification: { method: 'official Cursor rules and CLI documentation', source: 'https://docs.cursor.com/context/rules-for-ai', lastVerified: VERIFIED_ON },
     },
+    'deepseek-harness': {
+        startupFiles: ['AGENTS.md', 'CLAUDE.md'],
+        precedence: ['provider/system', 'project AGENTS.md or CLAUDE.md', 'nested project context'],
+        loadMode: 'prose-directive', includeSyntax: null, configRegistration: null,
+        bootstrapTargets: ['AGENTS.md'], maxContextBytes: 65536, recommendedMaxLines: null, nestedContext: true, support: 'supported',
+        verification: {
+            method: 'DeepSeek Harness instruction and filesystem-skill source review',
+            source: 'https://github.com/deepseek-ai/deepseek-harness',
+            lastVerified: '2026-09-05',
+        },
+    },
     factory: {
         startupFiles: ['AGENTS.md', '~/.factory/AGENTS.md'], precedence: ['provider/system', 'nearest AGENTS.md', 'root AGENTS.md', 'personal override'],
         loadMode: 'prose-directive', includeSyntax: null, configRegistration: null,
@@ -731,6 +751,35 @@ const BUILT_IN_SEEDS = [
         },
         matrixRef: 'openhuman',
     },
+    {
+        id: 'deepseek-harness',
+        displayName: 'DeepSeek Harness',
+        aliases: ['dsh'],
+        builtIn: true,
+        upstream: {
+            source: 'https://github.com/deepseek-ai/deepseek-harness',
+            version: 'dsh-v0.1.3-alpha.1',
+            revision: 'd347e703908d0406b7a7ef80e3a0e594d86b2215',
+            runtime: 'Node.js ^22.19.0 || >=24.0.0',
+            lastVerified: '2026-09-05',
+        },
+        surfaces: {
+            primary: 'dsh', compatibility: ['deepseek-harness'],
+            precedence: ['AGENTS.md', 'CLAUDE.md', '.agents/skills/', '.dsh/skills/', '.dsh/aiwg.cordis.patch.yml'], related: [],
+        },
+        detection: { env: ['DSH_HOME'], process: ['dsh'], capabilityId: 'deepseek-harness' },
+        paths: {
+            artifacts: { agents: '.agents/skills', commands: null, skills: '.agents/skills', rules: null, behaviors: null },
+            kernelSkills: '.agents/skills',
+            contextDiscovery: { agents: '.agents/skills', skills: '.agents/skills', rules: null, behaviors: null },
+            configFile: '.dsh/aiwg.cordis.patch.yml',
+            contextFiles: { aiwgMd: true, agentsMd: true, claudeMdHook: false, hookFile: null, contextFile: 'AGENTS.md' },
+        },
+        smithPaths: { agents: '.agents/skills', commands: null, skills: '.agents/skills', rules: null, fileExtension: '.md', configFile: '.dsh/aiwg.cordis.patch.yml', aggregated: false },
+        skillNamespace: { deploymentGroup: 'deep-recursion', pathType: 'project', skillsBaseDir: '.agents/skills', subdirLayout: true },
+        adapters: { agentFormat: 'agents-md', hookBridge: null, mcpInjection: null, contextAggregation: 'agents-md', ruleFormat: 'agents-md-section' },
+        matrixRef: 'deepseek-harness',
+    },
     {
         id: 'omp',
         aliases: ['oh-my-pi'],

package/dist/src/providers/provider-inventory.js

@@ -10,6 +10,7 @@ const PROVIDER_EXECUTABLES = {
     codex: ['codex'],
     copilot: ['github-copilot-cli', 'copilot'],
     cursor: ['cursor'],
+    'deepseek-harness': ['dsh'],
     factory: ['droid'],
     hermes: ['hermes'],
     opencode: ['opencode'],

package/dist/src/providers/transformation-receipt.js

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { projectAiwgPath, projectAiwgWritePath } from '../config/project-artifacts.js';
 export const PROVIDER_TRANSFORMATION_RECEIPT_SCHEMA = 'aiwg.provider-transformation-receipt.v1';
 const SHA256 = /^[a-f0-9]{64}$/;
 const IDENTIFIER = /^[a-zA-Z0-9][a-zA-Z0-9._:/@+-]*$/;
@@ -52,7 +53,7 @@ export function providerTransformationReceiptPath(projectRoot, provider, scope)
     filenameSegment(provider, 'provider');
     if (scope !== 'project' && scope !== 'user')
         throw new Error('scope must be project or user');
-    return path.join(projectRoot, '.aiwg', 'receipts', 'providers', `${provider}.${scope}.json`);
+    return projectAiwgPath(projectRoot, 'receipts', 'providers', `${provider}.${scope}.json`);
 }
 export function validateProviderTransformationReceipt(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -108,7 +109,7 @@ export async function createProviderTransformationReceipt(options) {
 }
 export async function writeProviderTransformationReceipt(projectRoot, receipt) {
     validateProviderTransformationReceipt(receipt);
-    const destination = providerTransformationReceiptPath(projectRoot, receipt.provider, receipt.scope);
+    const destination = projectAiwgWritePath(projectRoot, 'receipts', 'providers', `${receipt.provider}.${receipt.scope}.json`);
     await mkdir(path.dirname(destination), { recursive: true });
     try {
         const existing = validateProviderTransformationReceipt(JSON.parse(await readFile(destination, 'utf8')));

package/dist/src/sessions/adapters/deepseek-harness.js

@@ -0,0 +1,178 @@
+import { opendir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, } from '../contracts.js';
+import { readBoundedJsonLines, streamBoundedJsonLines } from '../readers.js';
+export const DEEPSEEK_HARNESS_ADAPTER_VERSION = '1.0.0';
+export const DEEPSEEK_HARNESS_SOURCE_SCHEMA_VERSION = '2.0.0';
+const Header = z.object({
+    type: z.literal('session'), version: z.number().int(), id: z.string().min(1),
+    createdAt: z.number().finite(), cwd: z.string().optional(), parentSession: z.string().optional(),
+    isSeeded: z.boolean(), origin: z.literal('subagent').optional(),
+    delegationDepth: z.number().int().nonnegative(), agentPreset: z.string().optional(),
+}).passthrough();
+const Event = z.object({
+    type: z.string().min(1), seq: z.number().int().nonnegative(), time: z.number().finite(),
+    data: z.unknown(),
+}).passthrough();
+const KNOWN = new Set([
+    'turn/start', 'user/message', 'step/start', 'assistant/message', 'tool/call',
+    'tool/result', 'request/header', 'request/context', 'session/end-seed',
+    'step/end', 'turn/end',
+]);
+export class DeepSeekHarnessSessionAdapter {
+    limits;
+    maxFiles;
+    provider = 'deepseek-harness';
+    adapterVersion = DEEPSEEK_HARNESS_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['discover', 'inspect', 'stream'];
+    acquisitionModes = ['jsonl'];
+    constructor(limits, maxFiles = 10_000) {
+        this.limits = limits;
+        this.maxFiles = maxFiles;
+    }
+    async *discover(scope) {
+        if (!scope.allowedRoots.length)
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'DeepSeek Harness discovery requires an explicitly authorized sessions root');
+        let count = 0;
+        for (const root of [...scope.allowedRoots].sort()) {
+            for await (const locator of jsonlFiles(resolve(root))) {
+                if (++count > this.maxFiles)
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'DeepSeek Harness discovery file limit exceeded');
+                yield { provider: this.provider, locator, locatorClass: 'deepseek-harness-session-v2-jsonl' };
+            }
+        }
+    }
+    async inspect(source) {
+        let input;
+        try {
+            input = await readBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: this.limits });
+        }
+        catch (error) {
+            throw normalizeAuthorizationError(error);
+        }
+        const header = parseHeader(input.records[0]?.value);
+        if (input.incompleteTail)
+            throw new SessionContractError('TRUNCATED_SOURCE', 'DeepSeek Harness session has a truncated JSONL tail');
+        return { sourceSchemaVersion: `${header.version}.0.0`, consistency: 'complete', operationalState: 'available' };
+    }
+    async *stream(source, cursor) {
+        let input;
+        try {
+            input = await streamBoundedJsonLines({ selectedPath: source.locator, allowedRoots: source.authorizedScope.allowedRoots }, { consistency: 'provisional', limits: this.limits });
+        }
+        catch (error) {
+            throw normalizeAuthorizationError(error);
+        }
+        const start = cursor?.value.replace(/^byte:/, '') ?? '0';
+        if (!/^\d+$/.test(start))
+            throw new SessionContractError('SCHEMA_DRIFT', 'invalid DeepSeek Harness cursor');
+        let header;
+        let expectedSeq = 0;
+        let end = 0;
+        for await (const line of input) {
+            end = line.byteOffset + line.byteLength;
+            if (Number(start) > line.byteOffset && Number(start) < end)
+                throw new SessionContractError('SCHEMA_DRIFT', 'DeepSeek Harness cursor is not a record boundary');
+            if (!header) {
+                header = parseHeader(line.value);
+                continue;
+            }
+            const parsed = Event.safeParse(line.value);
+            if (!parsed.success)
+                throw new SessionContractError('MALFORMED_SOURCE', 'DeepSeek Harness session event is malformed');
+            const event = parsed.data;
+            if (event.seq !== expectedSeq)
+                throw new SessionContractError(event.seq < expectedSeq ? 'DUPLICATE_NATIVE_ID' : 'SCHEMA_DRIFT', `DeepSeek Harness sequence expected ${expectedSeq}, received ${event.seq}`);
+            expectedSeq++;
+            if (end <= Number(start))
+                continue;
+            const data = object(event.data);
+            const message = object(data.message ?? event.data);
+            const sensitive = isSensitive(event.type);
+            const source = object(message.source);
+            const role = event.type === 'user/message' ? 'user' : event.type === 'assistant/message' ? 'assistant' : undefined;
+            const text = sensitive ? '[redacted provider content]' : textContent(message.content ?? data.content);
+            const terminal = event.type === 'turn/end';
+            yield {
+                nativeSessionId: header.id,
+                nativeEventId: `${header.id}:${event.seq}`,
+                sequence: event.seq,
+                kind: kindFor(event.type, role),
+                role,
+                toolName: event.type.startsWith('tool/') ? string(data.name) ?? string(data.toolName) : undefined,
+                toolCallId: event.type.startsWith('tool/') ? string(data.id) ?? string(data.toolCallId) : undefined,
+                model: string(source.model) ?? string(data.model),
+                occurredAt: new Date(event.time).toISOString(),
+                text,
+                sourceCursor: `byte:${end}`,
+                sourceBytes: line.byteLength,
+                rawReference: { locatorClass: 'deepseek-harness-session-v2-jsonl', offset: line.byteOffset },
+                activityBoundary: terminal ? 'end' : undefined,
+                activityBoundaryBasis: terminal ? 'deepseek-harness:turn/end' : undefined,
+                activityBoundaryConfidence: terminal ? 'high' : undefined,
+                extensions: {
+                    provenance: { acquisition: 'deepseek-harness-session-v2', cwd: header.cwd, parentSession: header.parentSession, origin: header.origin },
+                    opaque: !KNOWN.has(event.type), redacted: sensitive, nativeType: event.type,
+                    turn: integer(data.turn), step: integer(data.step), delegationDepth: header.delegationDepth,
+                    agentPreset: header.agentPreset, provider: string(source.provider), model: string(source.model),
+                },
+            };
+        }
+        if (!header)
+            throw new SessionContractError('MALFORMED_SOURCE', 'DeepSeek Harness session header is missing');
+        if (Number(start) > end)
+            throw new SessionContractError('SCHEMA_DRIFT', 'DeepSeek Harness cursor exceeds source size');
+        if (input.incompleteTail)
+            throw new SessionContractError('TRUNCATED_SOURCE', 'DeepSeek Harness session has a truncated JSONL tail');
+    }
+}
+function parseHeader(value) {
+    const parsed = Header.safeParse(value);
+    if (!parsed.success)
+        throw new SessionContractError('MALFORMED_SOURCE', 'DeepSeek Harness session header is malformed');
+    if (parsed.data.version !== 2)
+        throw new SessionContractError('UNKNOWN_SCHEMA_MAJOR', `unsupported DeepSeek Harness session version: ${parsed.data.version}`);
+    return parsed.data;
+}
+function isSensitive(type) { return !KNOWN.has(type) || type === 'tool/call' || type === 'tool/result' || type === 'request/header' || type === 'request/context'; }
+function kindFor(type, role) { return role ? `message.${role}` : `deepseek-harness.${type}`; }
+function object(value) { return value && typeof value === 'object' ? value : {}; }
+function string(value) { return typeof value === 'string' && value ? value : undefined; }
+function integer(value) { return Number.isInteger(value) ? value : undefined; }
+function textContent(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value.flatMap(part => {
+        if (typeof part === 'string')
+            return part;
+        const item = object(part);
+        return item.type === 'text' && typeof item.text === 'string' ? item.text : [];
+    }).join('\n');
+}
+async function* jsonlFiles(root) {
+    let directory;
+    try {
+        directory = await opendir(root);
+    }
+    catch {
+        return;
+    }
+    for await (const entry of directory) {
+        const path = resolve(root, entry.name);
+        if (entry.isDirectory())
+            yield* jsonlFiles(path);
+        else if (entry.isFile() && entry.name.endsWith('.jsonl') && !entry.name.endsWith('.jsonl.zstd'))
+            yield path;
+    }
+}
+function normalizeAuthorizationError(error) {
+    if (error instanceof SessionContractError && ['SOURCE_OUTSIDE_ALLOWED_ROOT', 'SOURCE_SYMLINK', 'SOURCE_NOT_REGULAR_FILE'].includes(error.code)) {
+        return new SessionContractError('SOURCE_NOT_AUTHORIZED', 'DeepSeek Harness source is not an authorized regular file');
+    }
+    return error;
+}
+//# sourceMappingURL=deepseek-harness.js.map

package/dist/src/sessions/batch-import.js

@@ -1,4 +1,5 @@
 import { OmpSessionAdapter, OMP_ADAPTER_VERSION } from './adapters/omp.js';
+import { DeepSeekHarnessSessionAdapter, DEEPSEEK_HARNESS_ADAPTER_VERSION } from './adapters/deepseek-harness.js';
 import { stat } from 'node:fs/promises';
 import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, } from './adapters/claude.js';
 import { CODEX_ADAPTER_VERSION, CodexSessionAdapter, } from './adapters/codex.js';
@@ -198,6 +199,8 @@ async function assertManifestSourceUnchanged(source) {
     }
 }
 function adapterFor(provider) {
+    if (provider === 'deepseek-harness')
+        return new DeepSeekHarnessSessionAdapter();
     if (provider === 'omp')
         return new OmpSessionAdapter();
     if (provider === 'claude')
@@ -229,6 +232,8 @@ async function sessionSource(selected, adapter) {
     });
 }
 function adapterVersion(provider) {
+    if (provider === 'deepseek-harness')
+        return DEEPSEEK_HARNESS_ADAPTER_VERSION;
     if (provider === 'omp')
         return OMP_ADAPTER_VERSION;
     if (provider === 'claude')
@@ -242,6 +247,8 @@ function adapterVersion(provider) {
     return '1.0.0';
 }
 function providerProfile(provider, locatorClass) {
+    if (provider === 'deepseek-harness')
+        return 'native-session-v2-jsonl';
     if (provider === 'omp')
         return 'native-title-slot-v3';
     if (provider === 'claude')

package/dist/src/sessions/contracts.js

@@ -3,11 +3,12 @@ import { z } from 'zod';
 export const SESSION_CONTRACT_VERSION = '1.0.0';
 export const SESSION_PROVIDER_IDS = [
     'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
-    'opencode', 'openclaw', 'openhuman', 'pi', 'omp', 'warp', 'devin-desktop', 'generic',
+    'opencode', 'openclaw', 'openhuman', 'pi', 'omp', 'deepseek-harness', 'warp', 'devin-desktop', 'generic',
 ];
 export const SessionProviderIdSchema = z.enum(SESSION_PROVIDER_IDS);
 export const SESSION_PROVIDER_ALIASES = Object.freeze({
     windsurf: 'devin-desktop',
+    dsh: 'deepseek-harness',
 });
 const CompatibleSessionProviderIdSchema = z.preprocess((value) => typeof value === 'string'
     ? (SESSION_PROVIDER_ALIASES[value] ?? value)

package/dist/src/sessions/index.js

@@ -29,6 +29,7 @@ export * from './adapters/opencode.js';
 export * from './adapters/openclaw.js';
 export * from './adapters/openhuman.js';
 export * from './adapters/pi.js';
+export * from './adapters/deepseek-harness.js';
 export * from './adapters/warp.js';
 export * from './adapters/windsurf.js';
 export * from './adapters/omp.js';