@spences10/pi-harness 0.1.1 → 0.2.0

package/dist/extension.js

@@ -1,308 +1,92 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { HARNESS_ASSESSMENT_CUSTOM_TYPE, assessment_active, assessment_context, assessment_tool_names, check_assessment_command, create_assessment_state, format_assessment_record, harness_assess_params_schema, harness_assessment_submit_params_schema, is_assessment_tool_allowed, submit_assessment_record, } from './assessment.js';
+import { HARNESS_ASSESSMENT_CUSTOM_TYPE, assessment_active, assessment_context, create_assessment_state, format_assessment_record, harness_assess_params_schema, harness_assessment_submit_params_schema, submit_assessment_record, } from './assessment.js';
 import { check_command_allowed, check_path_allowed, } from './enforcement/policy.js';
 import { HARNESS_SYSTEM_PROMPT } from './prompt.js';
-import { harness_paths, read_contract, read_status, } from './runtime/files.js';
+import { harness_paths, read_contract, read_status, shell_quote, } from './runtime/files.js';
 import { active_harness_context, amend_harness_runtime, create_harness_runtime, format_harness_status_line, format_harness_summary, update_harness_runtime, } from './runtime/index.js';
+import { resolve_harness_cwd } from './runtime/verification.js';
 import { HARNESS_CUSTOM_TYPE, harness_amend_params_schema, harness_create_params_schema, harness_read_params_schema, harness_update_params_schema, } from './schema.js';
-function persist_active_harness(pi, harness_dir) {
-    pi.appendEntry(HARNESS_CUSTOM_TYPE, {
-        active_harness_dir: harness_dir,
-    });
-}
-function restore_active_harness(ctx) {
-    const entries = ctx.sessionManager.getEntries();
-    return entries
-        .filter((entry) => entry.type === 'custom' &&
-        entry.customType === HARNESS_CUSTOM_TYPE)
-        .pop()?.data?.active_harness_dir;
-}
-function restore_assessment(ctx) {
-    const entries = ctx.sessionManager.getBranch();
-    return entries
-        .filter((entry) => entry.type === 'custom' &&
-        entry.customType === HARNESS_ASSESSMENT_CUSTOM_TYPE)
-        .pop()?.data;
-}
-function update_harness_ui(ctx, harness_dir) {
-    if (!harness_dir ||
-        !existsSync(harness_paths(harness_dir).contract)) {
-        ctx.ui.setStatus('harness', undefined);
-        ctx.ui.setWidget('harness', undefined);
-        return;
-    }
-    ctx.ui.setStatus('harness', format_harness_status_line(harness_dir));
-    ctx.ui.setWidget('harness', undefined);
-}
-function update_assessment_ui(ctx, state) {
-    if (!state || !assessment_active(state)) {
-        ctx.ui.setStatus('harness-assessment', undefined);
-        return;
-    }
-    const label = state.status === 'awaiting_approval'
-        ? '🔎 assess: approval'
-        : '🔎 assess';
-    ctx.ui.setStatus('harness-assessment', label);
-}
-function parse_command(args) {
-    const [command = 'status', ...rest] = args.trim().split(/\s+/);
-    return { command, rest: rest.join(' ').trim() };
-}
-function tool_text(text) {
-    return { content: [{ type: 'text', text }], details: {} };
-}
+const tool_text = (text) => ({
+    content: [{ type: 'text', text }],
+    details: {},
+});
 export function should_inject_harness_prompt(event) {
-    const selected_tools = event.systemPromptOptions?.selectedTools;
-    return !selected_tools || selected_tools.includes('bash');
+    const selected = event.systemPromptOptions?.selectedTools;
+    return !selected || selected.includes('bash');
 }
-function is_terminal_harness(harness_dir) {
-    if (!harness_dir ||
-        !existsSync(harness_paths(harness_dir).status)) {
-        return false;
-    }
-    const status = read_status(harness_dir).status;
-    return status === 'completed' || status === 'failed';
-}
-export default async function harness(pi) {
+export default function harness(pi) {
     let active_harness_dir;
-    let assessment_state;
-    let decision_prompt_open = false;
-    function set_active_harness(harness_dir, ctx) {
-        active_harness_dir = harness_dir;
-        persist_active_harness(pi, harness_dir);
-        update_harness_ui(ctx, harness_dir);
-    }
-    function persist_assessment(state, ctx) {
-        assessment_state = state;
-        pi.appendEntry(HARNESS_ASSESSMENT_CUSTOM_TYPE, state);
-        update_assessment_ui(ctx, state);
+    let assessment;
+    function update_ui(ctx) {
+        ctx.ui.setStatus('harness', active_harness_dir &&
+            existsSync(harness_paths(active_harness_dir).status)
+            ? format_harness_status_line(active_harness_dir)
+            : undefined);
+        ctx.ui.setStatus('harness-assessment', assessment_active(assessment) ? '🔎 assess' : undefined);
     }
-    function start_assessment(task, source, ctx) {
-        const normalized_task = task.trim();
-        if (assessment_active(assessment_state) &&
-            assessment_state?.task === normalized_task) {
-            return assessment_state;
-        }
-        const tools_before_assessment = assessment_active(assessment_state)
-            ? assessment_state?.tools_before_assessment
-            : pi.getActiveTools();
-        const state = create_assessment_state(normalized_task, source, tools_before_assessment ?? pi.getActiveTools());
-        persist_assessment(state, ctx);
-        pi.setActiveTools(assessment_tool_names(state.tools_before_assessment));
-        return state;
+    function set_active(dir, ctx) {
+        active_harness_dir = dir;
+        pi.appendEntry(HARNESS_CUSTOM_TYPE, { active_harness_dir: dir });
+        update_ui(ctx);
     }
-    function restore_tools_after_assessment(state) {
-        pi.setActiveTools(state.tools_before_assessment);
+    function start_assessment(task, ctx) {
+        assessment = create_assessment_state(task, 'user');
+        pi.appendEntry(HARNESS_ASSESSMENT_CUSTOM_TYPE, assessment);
+        update_ui(ctx);
+        return assessment;
     }
-    function complete_assessment(decision, ctx) {
-        const current = assessment_state;
-        const record = current?.record;
-        if (!current ||
-            current.status !== 'awaiting_approval' ||
-            !record) {
-            ctx.ui.notify('No assessment is awaiting approval', 'warning');
-            return;
-        }
-        if (decision === 'direct' &&
-            active_harness_dir &&
-            !is_terminal_harness(active_harness_dir)) {
-            ctx.ui.notify('Direct work cannot bypass the active harness; submit an approved harness contract to amend it', 'warning');
-            return;
-        }
-        if (decision === 'harness') {
-            if (!record.proposed_contract) {
-                ctx.ui.notify('This assessment has no proposed harness contract', 'warning');
-                return;
-            }
-            const approved = {
-                ...current,
-                status: 'approved',
-                decision,
-            };
-            if (active_harness_dir &&
-                !is_terminal_harness(active_harness_dir)) {
-                if (record.proposed_contract.cwd ||
-                    record.proposed_contract.forbidden_paths?.length ||
-                    record.proposed_contract.forbidden_commands?.length) {
-                    ctx.ui.notify('Outer-policy changes require a separate harness contract', 'warning');
-                    return;
-                }
-                const contract = amend_harness_runtime({
-                    harness_dir: active_harness_dir,
-                    reason: `Approved assessment ${approved.id} v${approved.version}`,
-                    requested_by: 'user',
-                    task: record.proposed_contract.task,
-                    allowed_paths: record.proposed_contract.allowed_paths,
-                    validation_commands: record.proposed_contract.validation_commands,
-                    allow_test_changes: record.proposed_contract.allow_test_changes,
-                    escalation_rules: record.proposed_contract.escalation_rules,
-                    planner_model: record.proposed_contract.planner_model,
-                    planner_thinking: record.proposed_contract.planner_thinking,
-                    executor_model: record.proposed_contract.executor_model,
-                    executor_thinking: record.proposed_contract.executor_thinking,
-                    reviewer_model: record.proposed_contract.reviewer_model,
-                    reviewer_thinking: record.proposed_contract.reviewer_thinking,
-                });
-                persist_assessment(approved, ctx);
-                restore_tools_after_assessment(approved);
-                set_active_harness(active_harness_dir, ctx);
-                return {
-                    message: `The user approved assessment ${approved.id} v${approved.version}. Resume harness ${contract.id} with approved scaffold v${contract.scaffold.version} using the execute-harness skill. Harness approval does not authorize Factory; use Factory only after a direct user request to evaluate it.`,
-                    trigger: true,
-                };
-            }
-            persist_assessment(approved, ctx);
-            restore_tools_after_assessment(approved);
-            const { harness_dir, contract } = create_harness_runtime(record.proposed_contract, ctx.cwd);
-            set_active_harness(harness_dir, ctx);
-            return {
-                message: `The user approved assessment ${approved.id} v${approved.version}. Execute harness ${contract.id} from ${harness_dir} using the execute-harness skill. Harness approval does not authorize Factory; use Factory only after a direct user request to evaluate it.`,
-                trigger: true,
-            };
-        }
-        const completed = {
-            ...current,
-            status: decision === 'reject' ? 'rejected' : 'approved',
-            decision,
-        };
-        persist_assessment(completed, ctx);
-        restore_tools_after_assessment(completed);
-        if (decision === 'direct') {
-            return {
-                message: `The user approved direct work from assessment ${completed.id} v${completed.version}. Proceed only with the smallest vertical slice recorded in the assessment.`,
-                trigger: true,
-            };
-        }
-        return {
-            message: `The user rejected assessment ${completed.id} v${completed.version}. Do not implement the candidate work.`,
-            trigger: false,
-        };
-    }
-    function send_decision_message(result) {
-        pi.sendMessage({
-            customType: 'harness-assessment-decision',
-            content: result.message,
-            display: true,
-        }, {
-            triggerTurn: result.trigger,
-            deliverAs: 'followUp',
-        });
+    function require_active(dir) {
+        if (!active_harness_dir ||
+            resolve(dir) !== resolve(active_harness_dir))
+            throw new Error('Use /harness use <dir> to select this harness first');
     }
-    async function prompt_for_assessment_decision(ctx) {
-        const current = assessment_state;
-        if (decision_prompt_open ||
-            current?.status !== 'awaiting_approval' ||
-            !current.record ||
-            !ctx.hasUI) {
-            return;
-        }
-        decision_prompt_open = true;
-        try {
-            const harness_is_active = active_harness_dir &&
-                !is_terminal_harness(active_harness_dir);
-            const options = [
-                ...(current.record.proposed_contract
-                    ? [
-                        harness_is_active
-                            ? 'Approve and amend active harness'
-                            : 'Create and execute harness',
-                    ]
-                    : []),
-                ...(harness_is_active ? [] : ['Proceed with direct work']),
-                'Reject the proposed work',
-                'Keep assessing',
-            ];
-            const choice = await ctx.ui.select(`Assessment ${current.id} v${current.version}`, options);
-            if (assessment_state?.id !== current.id ||
-                assessment_state.version !== current.version) {
-                return;
-            }
-            const decision = choice?.startsWith('Create') || choice?.startsWith('Approve')
-                ? 'harness'
-                : choice?.startsWith('Proceed')
-                    ? 'direct'
-                    : choice?.startsWith('Reject')
-                        ? 'reject'
-                        : undefined;
-            if (!decision)
-                return;
-            const result = complete_assessment(decision, ctx);
-            if (result)
-                send_decision_message(result);
-        }
-        finally {
-            decision_prompt_open = false;
+    function restore(ctx) {
+        active_harness_dir = undefined;
+        assessment = undefined;
+        for (const entry of ctx.sessionManager.getBranch()) {
+            if (entry.type !== 'custom')
+                continue;
+            if (entry.customType === HARNESS_CUSTOM_TYPE)
+                active_harness_dir = entry.data?.active_harness_dir;
+            if (entry.customType === HARNESS_ASSESSMENT_CUSTOM_TYPE)
+                assessment = entry.data;
         }
+        if (active_harness_dir &&
+            existsSync(harness_paths(active_harness_dir).status) &&
+            read_status(active_harness_dir).status === 'completed')
+            set_active(undefined, ctx);
+        update_ui(ctx);
     }
     pi.registerCommand('assess', {
-        description: 'Assess candidate work before choosing direct execution, a harness, or rejection',
+        description: 'Optional investigation and recommendation; does not lock tools or create an approval gate',
         handler: async (args, ctx) => {
-            const trimmed = args.trim();
-            if (!trimmed || trimmed === 'status') {
-                if (!assessment_state) {
-                    ctx.ui.notify('No harness assessment', 'warning');
-                    return;
-                }
-                ctx.ui.notify(format_assessment_record(assessment_state), 'info');
-                return;
+            const task = args.trim();
+            if (!task || task === 'status') {
+                ctx.ui.notify(assessment
+                    ? format_assessment_record(assessment)
+                    : 'No assessment', 'info');
             }
-            if (trimmed === 'approve' || trimmed.startsWith('approve ')) {
-                const requested = trimmed.slice('approve'.length).trim();
-                if (requested === 'harness' || requested === 'direct') {
-                    const result = complete_assessment(requested, ctx);
-                    if (result)
-                        send_decision_message(result);
-                    return;
-                }
-                await prompt_for_assessment_decision(ctx);
-                return;
+            else if (task === 'clear') {
+                assessment = undefined;
+                pi.appendEntry(HARNESS_ASSESSMENT_CUSTOM_TYPE, undefined);
+                update_ui(ctx);
             }
-            if (trimmed === 'reject') {
-                const result = complete_assessment('reject', ctx);
-                if (result)
-                    send_decision_message(result);
-                return;
+            else if (/^(approve|reject)(?:\s|$)/.test(task)) {
+                ctx.ui.notify('Assessment is advisory. No approval roundtrip is required; use /harness create when useful.', 'info');
             }
-            if (trimmed === 'clear') {
-                if (assessment_state && assessment_active(assessment_state)) {
-                    restore_tools_after_assessment(assessment_state);
-                }
-                assessment_state = undefined;
-                pi.appendEntry(HARNESS_ASSESSMENT_CUSTOM_TYPE, undefined);
-                update_assessment_ui(ctx, undefined);
-                ctx.ui.notify('Cleared harness assessment', 'info');
-                return;
+            else {
+                pi.sendUserMessage(assessment_context(start_assessment(task, ctx)));
             }
-            const state = start_assessment(trimmed, 'user', ctx);
-            pi.sendUserMessage(`Assess this candidate work without modifying the repository. Use repository evidence and existing primitives before recommending direct work, a harness, or rejection.\n\n${state.task}`);
         },
     });
     pi.registerCommand('harness', {
-        description: 'Assess, run, review, and inspect ephemeral /tmp task harnesses',
+        description: 'Create, run, review, or inspect an optional task harness',
         handler: async (args, ctx) => {
-            const { command, rest } = parse_command(args);
+            const [command = 'status', ...words] = args.trim().split(/\s+/);
+            const rest = words.join(' ');
             if (command === 'clear') {
-                set_active_harness(undefined, ctx);
-                ctx.ui.notify('Cleared active harness', 'info');
-                return;
-            }
-            if (command === 'use') {
-                if (!rest) {
-                    ctx.ui.notify('Usage: /harness use <dir>', 'warning');
-                    return;
-                }
-                set_active_harness(rest, ctx);
-                ctx.ui.notify(`Active harness: ${rest}`, 'info');
-                return;
-            }
-            if (command === 'status') {
-                const harness_dir = rest || active_harness_dir;
-                if (!harness_dir) {
-                    ctx.ui.notify('No active harness', 'warning');
-                    return;
-                }
-                ctx.ui.notify(format_harness_summary(harness_dir), 'info');
+                set_active(undefined, ctx);
                 return;
             }
             if (command === 'create') {
@@ -310,203 +94,185 @@ export default async function harness(pi) {
                     ctx.ui.notify('Usage: /harness create <task>', 'warning');
                     return;
                 }
-                const state = start_assessment(rest, 'harness-create', ctx);
-                pi.sendUserMessage(`Assess this task before creating a harness. Do not treat candidate capabilities as implementation commitments.\n\n${state.task}`);
+                set_active(undefined, ctx);
+                pi.sendUserMessage(`Create a task harness with harness_create for: ${rest}. Use the project's normal acceptance checks and a suitable scope. No assessment or extra approval roundtrip is required. Do not expand the user-authorized task.`);
                 return;
             }
-            if (command === 'run') {
-                const harness_dir = rest || active_harness_dir;
-                if (!harness_dir) {
-                    ctx.ui.notify('Usage: /harness run <dir>', 'warning');
-                    return;
-                }
-                set_active_harness(harness_dir, ctx);
-                pi.sendUserMessage(`Use the execute-harness skill to run this harness until validation completes: ${harness_dir}. Harness execution does not authorize Factory; use Factory only after a direct user request to evaluate it. If the team tool is available, create or reuse a team and create a task for this harness. Use one mutating teammate only when useful; use a worktree only when isolation and merge ownership are explicit. Then inspect team status/results before reporting.`);
+            const dir = rest || active_harness_dir;
+            if (!dir) {
+                ctx.ui.notify('No active harness. Use /harness create <task>.', 'info');
                 return;
             }
-            if (command === 'review') {
-                const harness_dir = rest || active_harness_dir;
-                if (!harness_dir) {
-                    ctx.ui.notify('Usage: /harness review <dir>', 'warning');
-                    return;
-                }
-                set_active_harness(harness_dir, ctx);
-                pi.sendUserMessage(`Use the review-harness skill to review drift, shortcuts, validation evidence, and remaining risks for: ${harness_dir}`);
-                return;
+            if (command === 'use' ||
+                command === 'run' ||
+                command === 'review') {
+                if (!existsSync(harness_paths(dir).contract))
+                    throw new Error('Harness contract does not exist');
+                set_active(dir, ctx);
+                if (command !== 'use')
+                    pi.sendUserMessage(`Use the ${command === 'review' ? 'review' : 'execute'}-harness skill for ${dir}. Work directly unless the user has authorized peer collaboration; Team Mode only coordinates existing sessions.`);
             }
-            ctx.ui.notify('Usage: /harness create|run|review|status|use|clear', 'info');
+            else if (command === 'status')
+                ctx.ui.notify(format_harness_summary(dir), 'info');
+            else
+                ctx.ui.notify('Usage: /harness create|run|review|status|use|clear', 'info');
         },
     });
     pi.registerTool({
         name: 'harness_assess',
-        label: 'Start Harness Assessment',
-        description: 'Enter read-only assessment before deciding whether candidate work should run directly, use a harness, or be rejected.',
-        promptSnippet: 'Enter read-only evidence-gated assessment before adopting broad or risky work',
-        promptGuidelines: [
-            'Call harness_assess before repository mutation when a task may need an enforceable harness contract.',
-            'Call harness_assess by itself; after it activates, use only the remaining read-only tools.',
-        ],
+        label: 'Assess Task',
+        description: 'Optional advisory investigation. Does not restrict tools or require another approval.',
         parameters: harness_assess_params_schema,
-        async execute(_tool_call_id, params, _signal, _on_update, ctx) {
-            const state = start_assessment(params.task, 'agent', ctx);
-            return tool_text(assessment_context(state));
+        executionMode: 'sequential',
+        async execute(_id, params, _signal, _update, ctx) {
+            return tool_text(assessment_context(start_assessment(params.task, ctx)));
         },
     });
     pi.registerTool({
         name: 'harness_assessment_submit',
-        label: 'Submit Harness Assessment',
-        description: 'Submit repository evidence and one recommendation for direct work, a harness contract, or rejection. Direct user approval is still required.',
+        label: 'Record Assessment',
+        description: 'Record an optional recommendation; does not create or approve a harness.',
         parameters: harness_assessment_submit_params_schema,
-        async execute(_tool_call_id, params, _signal, _on_update, ctx) {
-            if (params.proposed_contract?.cwd &&
-                resolve(params.proposed_contract.cwd) !== resolve(ctx.cwd)) {
-                throw new Error('Proposed harness cwd must match the assessed project');
-            }
-            const current = assessment_state ??
-                start_assessment(params.task, 'agent', ctx);
-            const submitted = submit_assessment_record(current, params);
-            persist_assessment(submitted, ctx);
-            return tool_text(`${format_assessment_record(submitted)}\n\nWaiting for direct user approval.`);
+        executionMode: 'sequential',
+        async execute(_id, params, _signal, _update, ctx) {
+            assessment = submit_assessment_record(assessment ?? create_assessment_state(params.task, 'agent'), params);
+            pi.appendEntry(HARNESS_ASSESSMENT_CUSTOM_TYPE, assessment);
+            update_ui(ctx);
+            return tool_text(format_assessment_record(assessment));
         },
     });
     pi.registerTool({
         name: 'harness_create',
         label: 'Create Harness',
-        description: 'Request an ephemeral /tmp task harness. An approved assessment is required before creation.',
-        promptSnippet: 'Request constrained execution only after evidence-gated assessment and direct user approval',
-        promptGuidelines: [
-            'Use harness_assess before harness_create. An unapproved harness_create call is blocked and starts assessment.',
-            'Use the normal direct workflow for bounded, low-risk changes covered by standard validation.',
-        ],
+        description: 'Create a task contract with accepted validation commands and optional scope. Assessment is not required.',
         parameters: harness_create_params_schema,
-        async execute(_tool_call_id, params, _signal, _on_update, ctx) {
-            const state = start_assessment(params.task, 'harness-create', ctx);
-            return tool_text(`Harness not created. Complete and obtain approval for assessment ${state.id}.`);
+        executionMode: 'sequential',
+        async execute(_id, params, _signal, _update, ctx) {
+            if (active_harness_dir)
+                throw new Error('A harness is already active; the user can /harness clear or /harness create a new task');
+            if (params.cwd && resolve(params.cwd) !== resolve(ctx.cwd))
+                throw new Error('Harness cwd must match the current project');
+            const { harness_dir } = create_harness_runtime(params, ctx.cwd);
+            if (assessment_active(assessment)) {
+                assessment = undefined;
+                pi.appendEntry(HARNESS_ASSESSMENT_CUSTOM_TYPE, undefined);
+            }
+            set_active(harness_dir, ctx);
+            return tool_text(format_harness_summary(harness_dir));
         },
     });
     pi.registerTool({
         name: 'harness_amend',
-        label: 'Amend Harness Scaffold',
-        description: 'Amend the active execution scaffold with an audited version change. Cannot weaken the outer runtime policy.',
-        promptSnippet: 'Amend bounded task scope, validation, test policy, or model strategy when evidence changes',
-        promptGuidelines: [
-            'Use harness_amend for bounded changes to the inner scaffold.',
-            'New capabilities, architecture decisions, or outer-policy expansion require assessment instead of a silent amendment.',
-        ],
+        label: 'Amend Strategy',
+        description: 'Adjust the execution plan without removing accepted checks or expanding the accepted maximum scope.',
         parameters: harness_amend_params_schema,
-        async execute(_tool_call_id, params, _signal, _on_update, ctx) {
-            const contract = amend_harness_runtime(params);
-            set_active_harness(params.harness_dir, ctx);
-            return tool_text(`Amended harness ${contract.id} scaffold to v${contract.scaffold.version}`);
+        executionMode: 'sequential',
+        async execute(_id, params, _signal, _update, ctx) {
+            require_active(params.harness_dir);
+            amend_harness_runtime({ ...params, requested_by: 'planner' });
+            update_ui(ctx);
+            return tool_text(format_harness_summary(params.harness_dir));
         },
     });
     pi.registerTool({
         name: 'harness_update',
         label: 'Update Harness',
-        description: 'Update harness status, phase, notes, and validation evidence.',
+        description: 'Record progress. Requesting completed runs accepted checks and the drift guard through normal tool hooks before recording success.',
         parameters: harness_update_params_schema,
-        async execute(_tool_call_id, params, _signal, _on_update, ctx) {
-            const status_file = update_harness_runtime(params);
-            set_active_harness(params.harness_dir, ctx);
-            return tool_text(`Updated harness ${status_file.id}: ${status_file.status}`);
+        executionMode: 'sequential',
+        async execute(_id, params, signal, _update, ctx) {
+            require_active(params.harness_dir);
+            try {
+                const status = await update_harness_runtime(params, {
+                    cwd: ctx.cwd,
+                    signal,
+                    run: async (command, cwd, run_signal) => {
+                        const outcome = await ctx.executeTool('bash', { command: `cd -- ${shell_quote(cwd)} && ${command}` }, { signal: run_signal });
+                        return {
+                            passed: outcome.isError === false,
+                            output: JSON.stringify(outcome.result),
+                        };
+                    },
+                });
+                return tool_text(`Harness ${status.status}. Evidence: ${harness_paths(params.harness_dir).outcome_markdown}`);
+            }
+            finally {
+                update_ui(ctx);
+            }
         },
     });
     pi.registerTool({
         name: 'harness_read',
         label: 'Read Harness',
-        description: 'Read a harness contract, status, and runtime file locations.',
+        description: 'Read the current task contract and outcome locations.',
         parameters: harness_read_params_schema,
-        async execute(_tool_call_id, params) {
+        async execute(_id, params) {
             return tool_text(format_harness_summary(params.harness_dir));
         },
     });
-    pi.on('session_start', async (_event, ctx) => {
-        active_harness_dir = restore_active_harness(ctx);
-        assessment_state = restore_assessment(ctx);
-        if (is_terminal_harness(active_harness_dir)) {
-            set_active_harness(undefined, ctx);
-        }
-        if (assessment_active(assessment_state)) {
-            pi.setActiveTools(assessment_tool_names(pi.getActiveTools()));
-        }
-        update_harness_ui(ctx, active_harness_dir);
-        update_assessment_ui(ctx, assessment_state);
-    });
+    pi.on('session_start', async (_event, ctx) => restore(ctx));
+    pi.on('session_tree', async (_event, ctx) => restore(ctx));
     pi.on('input', async (event, ctx) => {
         if (event.source !== 'extension' &&
-            is_terminal_harness(active_harness_dir)) {
-            set_active_harness(undefined, ctx);
-        }
+            active_harness_dir &&
+            existsSync(harness_paths(active_harness_dir).status) &&
+            ['completed', 'failed'].includes(read_status(active_harness_dir).status))
+            set_active(undefined, ctx);
     });
     pi.on('before_agent_start', async (event) => {
-        let system_prompt = event.systemPrompt;
-        if (should_inject_harness_prompt(event)) {
-            system_prompt = `${system_prompt}\n\n${HARNESS_SYSTEM_PROMPT}`;
-        }
-        const current_assessment = assessment_state;
-        if (current_assessment && assessment_active(current_assessment)) {
-            system_prompt = `${system_prompt}\n\n${assessment_context(current_assessment)}`;
+        const contexts = [
+            should_inject_harness_prompt(event)
+                ? HARNESS_SYSTEM_PROMPT
+                : '',
+            assessment_active(assessment) && assessment
+                ? assessment_context(assessment)
+                : '',
+            active_harness_dir &&
+                existsSync(harness_paths(active_harness_dir).contract)
+                ? active_harness_context(active_harness_dir)
+                : '',
+        ].filter(Boolean);
+        if (contexts.length) {
+            event.systemPromptOptions.sections.harness =
+                contexts.join('\n\n');
         }
-        if (active_harness_dir &&
-            existsSync(harness_paths(active_harness_dir).contract)) {
-            system_prompt = `${system_prompt}\n\n${active_harness_context(active_harness_dir)}`;
+        else {
+            delete event.systemPromptOptions.sections.harness;
         }
-        return { systemPrompt: system_prompt };
     });
     pi.on('tool_call', async (event, ctx) => {
-        if (event.toolName === 'harness_create') {
-            const input = event.input;
-            const task = input.task?.trim() || 'Unspecified harness request';
-            const state = start_assessment(task, 'harness-create', ctx);
-            return {
-                block: true,
-                reason: `Harness creation requires direct approval of an assessment. Assessment ${state.id} is active; investigate and call harness_assessment_submit.`,
-            };
-        }
-        const current_assessment = assessment_state;
-        if (current_assessment && assessment_active(current_assessment)) {
-            if (!is_assessment_tool_allowed(event.toolName)) {
-                return {
-                    block: true,
-                    reason: `Assessment ${current_assessment.id}: tool ${event.toolName} is not read-only and is disabled until the user decides.`,
-                };
-            }
-            if (event.toolName === 'bash') {
-                const input = event.input;
-                const result = check_assessment_command(input.command ?? '');
-                if (!result.ok) {
-                    return { block: true, reason: result.reason };
-                }
-            }
-        }
         if (!active_harness_dir ||
-            !existsSync(harness_paths(active_harness_dir).contract)) {
+            !existsSync(harness_paths(active_harness_dir).contract))
             return;
-        }
         const contract = read_contract(active_harness_dir);
         if (event.toolName === 'bash') {
-            const input = event.input;
-            const command = input.command ?? '';
-            const result = check_command_allowed(contract, command);
+            const result = check_command_allowed(contract, String(event.input.command ?? ''));
             if (!result.ok)
                 return { block: true, reason: result.reason };
         }
-        if (event.toolName === 'edit' || event.toolName === 'write') {
+        if (event.toolName === 'write' || event.toolName === 'edit') {
             const input = event.input;
-            if (!input.path)
-                return;
-            const result = check_path_allowed(contract, input.path);
+            const path = input.path ?? input.file_path ?? input.filePath;
+            if (typeof path !== 'string')
+                return {
+                    block: true,
+                    reason: 'Harness mutation requires a known file path',
+                };
+            let cwd;
+            try {
+                cwd = resolve_harness_cwd(contract, ctx.cwd);
+            }
+            catch (error) {
+                return { block: true, reason: String(error) };
+            }
+            const result = check_path_allowed({ ...contract, policy: { ...contract.policy, cwd } }, path);
             if (!result.ok)
                 return { block: true, reason: result.reason };
         }
     });
-    pi.on('agent_end', async (_event, ctx) => {
-        await prompt_for_assessment_decision(ctx);
-    });
     pi.on('session_shutdown', async (_event, ctx) => {
         ctx.ui.setStatus('harness', undefined);
         ctx.ui.setStatus('harness-assessment', undefined);
-        ctx.ui.setWidget('harness', undefined);
     });
 }
 //# sourceMappingURL=extension.js.map