@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/http/helpers/autopilot-slice-utils.js

@@ -17,101 +17,136 @@ function ensurePrivateDirForFile(pathname) {
 }
 function autopilotSliceSchema() {
     // Strict enough to keep outputs predictable, but tolerant of older agents.
-    return {
-        type: "object",
-        additionalProperties: false,
-        required: ["status", "summary", "workstream_id"],
-        properties: {
-            status: {
-                type: "string",
-                enum: ["completed", "blocked", "needs_decision", "error"],
+    const artifactProperties = {
+        name: { type: "string", minLength: 1 },
+        artifact_type: {
+            type: "string",
+            enum: ["pr", "commit", "document", "config", "report", "design", "retro", "other"],
+        },
+        confidence_score: { type: ["number", "null"], minimum: 0, maximum: 1 },
+        description: { type: ["string", "null"] },
+        url: { type: ["string", "null"] },
+        verification_steps: { type: ["array", "null"], items: { type: "string" } },
+        milestone_id: { type: ["string", "null"] },
+        task_ids: { type: ["array", "null"], items: { type: "string" } },
+    };
+    const decisionProperties = {
+        question: { type: "string", minLength: 1 },
+        summary: { type: ["string", "null"] },
+        options: { type: ["array", "null"], items: { type: "string" } },
+        urgency: {
+            type: ["string", "null"],
+            enum: ["low", "medium", "high", "urgent", null],
+        },
+        blocking: { type: "boolean" },
+    };
+    const skillEvidenceProperties = {
+        skill: { type: "string", minLength: 1 },
+        skill_file: { type: ["string", "null"] },
+        skill_sha256: { type: ["string", "null"] },
+        skill_heading: { type: ["string", "null"] },
+    };
+    const taskUpdateProperties = {
+        task_id: { type: "string", minLength: 1 },
+        status: { type: "string", enum: ["todo", "in_progress", "done", "blocked"] },
+        reason: { type: ["string", "null"] },
+    };
+    const milestoneUpdateProperties = {
+        milestone_id: { type: "string", minLength: 1 },
+        status: {
+            type: "string",
+            enum: ["planned", "in_progress", "completed", "at_risk", "cancelled"],
+        },
+        reason: { type: ["string", "null"] },
+    };
+    const topLevelProperties = {
+        status: {
+            type: "string",
+            enum: ["completed", "blocked", "needs_decision", "error"],
+        },
+        summary: { type: "string", minLength: 1 },
+        workstream_id: { type: "string", minLength: 1 },
+        workstream_title: { type: ["string", "null"] },
+        slice_id: { type: ["string", "null"] },
+        artifacts: {
+            type: ["array", "null"],
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: Object.keys(artifactProperties),
+                properties: artifactProperties,
             },
-            summary: { type: "string", minLength: 1 },
-            workstream_id: { type: "string", minLength: 1 },
-            workstream_title: { type: ["string", "null"] },
-            slice_id: { type: ["string", "null"] },
-            artifacts: {
-                type: ["array", "null"],
-                items: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["name", "artifact_type"],
-                    properties: {
-                        name: { type: "string", minLength: 1 },
-                        artifact_type: {
-                            type: "string",
-                            enum: ["pr", "commit", "document", "config", "report", "design", "other"],
-                        },
-                        description: { type: ["string", "null"] },
-                        url: { type: ["string", "null"] },
-                        verification_steps: { type: ["array", "null"], items: { type: "string" } },
-                        milestone_id: { type: ["string", "null"] },
-                        task_ids: { type: ["array", "null"], items: { type: "string" } },
-                    },
-                },
+        },
+        decisions_needed: {
+            type: ["array", "null"],
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: Object.keys(decisionProperties),
+                properties: decisionProperties,
             },
-            decisions_needed: {
-                type: ["array", "null"],
-                items: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["question"],
-                    properties: {
-                        question: { type: "string", minLength: 1 },
-                        summary: { type: ["string", "null"] },
-                        options: { type: ["array", "null"], items: { type: "string" } },
-                        urgency: {
-                            type: ["string", "null"],
-                            enum: ["low", "medium", "high", "urgent", null],
-                        },
-                        blocking: { type: ["boolean", "null"] },
-                    },
-                },
+        },
+        skill_evidence: {
+            type: ["array", "null"],
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: Object.keys(skillEvidenceProperties),
+                properties: skillEvidenceProperties,
             },
-            task_updates: {
-                type: ["array", "null"],
-                items: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["task_id", "status"],
-                    properties: {
-                        task_id: { type: "string", minLength: 1 },
-                        status: { type: "string", minLength: 1 },
-                        reason: { type: ["string", "null"] },
-                    },
-                },
+        },
+        task_updates: {
+            type: ["array", "null"],
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: Object.keys(taskUpdateProperties),
+                properties: taskUpdateProperties,
             },
-            milestone_updates: {
-                type: ["array", "null"],
-                items: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["milestone_id", "status"],
-                    properties: {
-                        milestone_id: { type: "string", minLength: 1 },
-                        status: { type: "string", minLength: 1 },
-                        reason: { type: ["string", "null"] },
-                    },
-                },
+        },
+        milestone_updates: {
+            type: ["array", "null"],
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: Object.keys(milestoneUpdateProperties),
+                properties: milestoneUpdateProperties,
             },
-            next_actions: { type: ["array", "null"], items: { type: "string" } },
         },
+        next_actions: { type: ["array", "null"], items: { type: "string" } },
+    };
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: Object.keys(topLevelProperties),
+        properties: topLevelProperties,
+        // Keep schema within Codex structured-output subset (no combinators like allOf/if/then).
+        // Status/decision consistency is enforced by coordinator post-parse.
     };
 }
 export function ensureAutopilotSliceSchemaPath(schemaFilename) {
     const file = join(getOrgxPluginConfigDir(), schemaFilename);
+    const nextSchemaRaw = JSON.stringify(autopilotSliceSchema(), null, 2);
     try {
-        if (existsSync(file))
-            return file;
+        if (existsSync(file)) {
+            try {
+                const existingRaw = readFileSync(file, "utf8").trim();
+                if (existingRaw === nextSchemaRaw)
+                    return file;
+            }
+            catch {
+                // continue and rewrite
+            }
+        }
         ensurePrivateDirForFile(file);
-        writeFileAtomicSync(file, JSON.stringify(autopilotSliceSchema(), null, 2), { mode: 0o600 });
+        writeFileAtomicSync(file, nextSchemaRaw, { mode: 0o600 });
         return file;
     }
     catch {
         // Fall back to best-effort write.
         try {
             ensurePrivateDirForFile(file);
-            writeFileSync(file, `${JSON.stringify(autopilotSliceSchema(), null, 2)}\n`, {
+            writeFileSync(file, `${nextSchemaRaw}\n`, {
                 encoding: "utf8",
                 mode: 0o600,
             });
@@ -123,19 +158,249 @@ export function ensureAutopilotSliceSchemaPath(schemaFilename) {
     }
 }
 export function parseSliceResult(raw) {
-    const trimmed = raw.trim();
+    const allowedStatuses = new Set(["completed", "blocked", "needs_decision", "error"]);
+    const stripUtf8Bom = (text) => text.replace(/^\uFEFF/, "");
+    const extractMarkdownJsonFences = (text) => {
+        const matches = text.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi);
+        const fences = [];
+        for (const match of matches) {
+            const inner = typeof match[1] === "string" ? match[1].trim() : "";
+            if (inner.length > 0)
+                fences.push(inner);
+        }
+        return fences;
+    };
+    const stripMarkdownJsonFence = (text) => {
+        const fenceCount = text.match(/```/g)?.length ?? 0;
+        if (fenceCount !== 2)
+            return text;
+        const fenced = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+        if (!fenced || typeof fenced[1] !== "string")
+            return text;
+        return fenced[1].trim();
+    };
+    const parseSliceJsonText = (text) => {
+        const normalized = stripUtf8Bom(stripMarkdownJsonFence(text.trim()));
+        const parsed = parseJsonSafe(normalized);
+        if (parsed && typeof parsed === "object" && isLikelySliceResult(parsed)) {
+            return normalizeSliceResult(parsed);
+        }
+        const fencedCandidates = extractMarkdownJsonFences(normalized);
+        for (let i = fencedCandidates.length - 1; i >= 0; i -= 1) {
+            const parsedInner = parseJsonSafe(stripUtf8Bom(fencedCandidates[i]));
+            if (parsedInner && typeof parsedInner === "object" && isLikelySliceResult(parsedInner)) {
+                return normalizeSliceResult(parsedInner);
+            }
+        }
+        return null;
+    };
+    const isLikelySliceResult = (value) => {
+        if (!value || typeof value !== "object")
+            return false;
+        const record = value;
+        const status = typeof record.status === "string" ? record.status : "";
+        const workstreamId = typeof record.workstream_id === "string" ? record.workstream_id : "";
+        const summary = typeof record.summary === "string" ? record.summary : "";
+        return (allowedStatuses.has(status) &&
+            summary.trim().length > 0 &&
+            workstreamId.trim().length > 0);
+    };
+    const normalizeSliceResult = (value) => {
+        const record = value;
+        const status = typeof record.status === "string" ? record.status : "";
+        const decisions = record.decisions_needed;
+        let changed = false;
+        let nextRecord = record;
+        if (Array.isArray(decisions)) {
+            const normalized = decisions.map((decision) => {
+                if (!decision || typeof decision !== "object")
+                    return decision;
+                const decisionRecord = decision;
+                if (typeof decisionRecord.blocking === "boolean")
+                    return decision;
+                changed = true;
+                return { ...decisionRecord, blocking: false };
+            });
+            if (changed)
+                nextRecord = { ...nextRecord, decisions_needed: normalized };
+        }
+        const hasBlockingDecision = (input) => Array.isArray(input.decisions_needed) &&
+            input.decisions_needed.some((decision) => {
+                if (!decision || typeof decision !== "object")
+                    return false;
+                return decision.blocking === true;
+            });
+        if (hasBlockingDecision(nextRecord) && status === "completed") {
+            changed = true;
+            nextRecord = { ...nextRecord, status: "needs_decision" };
+        }
+        const normalizedStatus = typeof nextRecord.status === "string" ? nextRecord.status : status;
+        if (normalizedStatus === "completed") {
+            const hasExplicitOutcomeArrays = Array.isArray(record.artifacts) ||
+                Array.isArray(record.task_updates) ||
+                Array.isArray(record.milestone_updates) ||
+                Array.isArray(record.decisions_needed);
+            const artifactsCount = Array.isArray(nextRecord.artifacts) ? nextRecord.artifacts.length : 0;
+            const taskUpdatesCount = Array.isArray(nextRecord.task_updates)
+                ? nextRecord.task_updates.length
+                : 0;
+            const milestoneUpdatesCount = Array.isArray(nextRecord.milestone_updates)
+                ? nextRecord.milestone_updates.length
+                : 0;
+            const hasOutcomes = artifactsCount > 0 ||
+                taskUpdatesCount > 0 ||
+                milestoneUpdatesCount > 0;
+            if (hasExplicitOutcomeArrays && !hasOutcomes) {
+                changed = true;
+                nextRecord = { ...nextRecord, status: "error" };
+            }
+        }
+        const finalStatus = typeof nextRecord.status === "string" ? nextRecord.status : "";
+        const requiresBlockingDecision = finalStatus === "blocked" || finalStatus === "needs_decision" || finalStatus === "error";
+        if (requiresBlockingDecision && !hasBlockingDecision(nextRecord)) {
+            const nextDecisions = Array.isArray(nextRecord.decisions_needed)
+                ? [...nextRecord.decisions_needed]
+                : [];
+            nextDecisions.push({
+                question: "Missing required blocking decision for non-completed status",
+                summary: "Parser inserted a blocking decision because blocked/needs_decision/error statuses require blocking=true.",
+                options: null,
+                urgency: "medium",
+                blocking: true,
+            });
+            changed = true;
+            nextRecord = { ...nextRecord, decisions_needed: nextDecisions };
+        }
+        return changed ? nextRecord : value;
+    };
+    const unwrapStructuredOutput = (value) => {
+        if (!value || typeof value !== "object")
+            return null;
+        const record = value;
+        const parseEmbeddedText = (candidate) => {
+            if (typeof candidate === "string") {
+                return parseSliceJsonText(candidate);
+            }
+            if (Array.isArray(candidate)) {
+                for (let i = candidate.length - 1; i >= 0; i -= 1) {
+                    const parsed = parseEmbeddedText(candidate[i]);
+                    if (parsed)
+                        return parsed;
+                }
+                return null;
+            }
+            if (!candidate || typeof candidate !== "object")
+                return null;
+            const candidateRecord = candidate;
+            if (typeof candidateRecord.value === "string") {
+                return parseSliceJsonText(candidateRecord.value);
+            }
+            if (typeof candidateRecord.text === "string") {
+                return parseSliceJsonText(candidateRecord.text);
+            }
+            const fromValue = parseEmbeddedText(candidateRecord.value);
+            if (fromValue)
+                return fromValue;
+            const fromText = parseEmbeddedText(candidateRecord.text);
+            if (fromText)
+                return fromText;
+            const fromOutputText = parseEmbeddedText(candidateRecord.output_text);
+            if (fromOutputText)
+                return fromOutputText;
+            return null;
+        };
+        const finalOutput = record.final_output;
+        if (finalOutput && typeof finalOutput === "object") {
+            if (isLikelySliceResult(finalOutput))
+                return normalizeSliceResult(finalOutput);
+            const parsedFinalOutput = parseEmbeddedText(finalOutput);
+            if (parsedFinalOutput)
+                return parsedFinalOutput;
+        }
+        if (typeof finalOutput === "string") {
+            const parsedFinalOutput = parseSliceJsonText(finalOutput);
+            if (parsedFinalOutput)
+                return parsedFinalOutput;
+        }
+        const structured = record.structured_output;
+        if (structured && typeof structured === "object") {
+            if (isLikelySliceResult(structured))
+                return normalizeSliceResult(structured);
+            const parsedStructured = parseEmbeddedText(structured);
+            if (parsedStructured)
+                return parsedStructured;
+        }
+        if (typeof structured === "string") {
+            const parsedStructured = parseSliceJsonText(structured);
+            if (parsedStructured)
+                return parsedStructured;
+        }
+        // Claude text-mode envelopes can sometimes return JSON in `result`.
+        const parsedResultObject = parseEmbeddedText(record.result);
+        if (parsedResultObject)
+            return parsedResultObject;
+        if (typeof record.result === "string") {
+            const parsedResult = parseSliceJsonText(record.result);
+            if (parsedResult)
+                return parsedResult;
+        }
+        if (typeof record.output_text === "string") {
+            const parsedOutputText = parseSliceJsonText(record.output_text);
+            if (parsedOutputText)
+                return parsedOutputText;
+        }
+        // Responses-style envelopes can return text in output/message/content arrays.
+        const output = record.output;
+        if (Array.isArray(output)) {
+            for (let i = output.length - 1; i >= 0; i -= 1) {
+                const item = output[i];
+                if (!item || typeof item !== "object")
+                    continue;
+                const itemRecord = item;
+                const directText = parseEmbeddedText(itemRecord.text);
+                if (directText)
+                    return directText;
+                const outputText = parseEmbeddedText(itemRecord.output_text);
+                if (outputText)
+                    return outputText;
+                if (!Array.isArray(itemRecord.content))
+                    continue;
+                for (let j = itemRecord.content.length - 1; j >= 0; j -= 1) {
+                    const content = itemRecord.content[j];
+                    if (!content || typeof content !== "object")
+                        continue;
+                    const contentRecord = content;
+                    const contentDirect = parseEmbeddedText(contentRecord);
+                    if (contentDirect)
+                        return contentDirect;
+                    const contentText = parseEmbeddedText(contentRecord.text);
+                    if (contentText)
+                        return contentText;
+                    const contentOutputText = parseEmbeddedText(contentRecord.output_text);
+                    if (contentOutputText)
+                        return contentOutputText;
+                }
+            }
+        }
+        return isLikelySliceResult(record) ? normalizeSliceResult(record) : null;
+    };
+    const trimmed = stripUtf8Bom(raw).trim();
     if (!trimmed)
         return null;
-    const direct = parseJsonSafe(trimmed);
-    if (direct && typeof direct === "object")
-        return direct;
+    const direct = parseJsonSafe(stripMarkdownJsonFence(trimmed));
+    const directUnwrapped = unwrapStructuredOutput(direct);
+    if (directUnwrapped && typeof directUnwrapped === "object")
+        return directUnwrapped;
+    const directTextParsed = parseSliceJsonText(trimmed);
+    if (directTextParsed && typeof directTextParsed === "object")
+        return directTextParsed;
     // Tolerant parse: extract the last complete top-level JSON object from mixed logs.
-    const extractLastTopLevelObject = (text) => {
+    const extractTopLevelObjects = (text) => {
         let inString = false;
         let escaped = false;
         let depth = 0;
         let start = -1;
-        let lastObject = null;
+        const objects = [];
         for (let i = 0; i < text.length; i += 1) {
             const ch = text[i];
             if (inString) {
@@ -167,18 +432,20 @@ export function parseSliceResult(raw) {
                     continue;
                 depth -= 1;
                 if (depth === 0 && start >= 0) {
-                    lastObject = text.slice(start, i + 1);
+                    objects.push(text.slice(start, i + 1));
                     start = -1;
                 }
             }
         }
-        return lastObject;
+        return objects;
     };
-    const candidate = extractLastTopLevelObject(trimmed);
-    if (candidate) {
+    const candidates = extractTopLevelObjects(trimmed);
+    for (let i = candidates.length - 1; i >= 0; i -= 1) {
+        const candidate = candidates[i];
         const parsed = parseJsonSafe(candidate);
-        if (parsed && typeof parsed === "object")
-            return parsed;
+        const unwrapped = unwrapStructuredOutput(parsed);
+        if (unwrapped && typeof unwrapped === "object")
+            return unwrapped;
     }
     return null;
 }
@@ -237,7 +504,13 @@ export function normalizeCodexArgs(args) {
         normalized.unshift("exec");
     }
     if (!normalized.includes("--skip-git-repo-check")) {
-        normalized.push("--skip-git-repo-check");
+        const passthroughIndex = normalized.indexOf("--");
+        if (passthroughIndex > -1) {
+            normalized.splice(passthroughIndex, 0, "--skip-git-repo-check");
+        }
+        else {
+            normalized.push("--skip-git-repo-check");
+        }
     }
     return normalized;
 }
@@ -423,7 +696,94 @@ export function createCodexBinResolver() {
         getCachedCodexProbeSummary,
     };
 }
+function normalizeSkillName(skill) {
+    return skill.replace(/^\$/, "").trim();
+}
+function skillAliasesFor(skill) {
+    const normalized = normalizeSkillName(skill);
+    if (!normalized)
+        return [];
+    const aliases = [normalized];
+    if (normalized.startsWith("orgx-"))
+        aliases.push(normalized.slice("orgx-".length));
+    if (normalized.endsWith("-agent"))
+        aliases.push(normalized.slice(0, -"-agent".length));
+    return Array.from(new Set(aliases.filter(Boolean)));
+}
+function buildSkillHints(requiredSkills) {
+    return requiredSkills
+        .map((skill) => {
+        const normalized = normalizeSkillName(skill);
+        const aliases = skillAliasesFor(normalized);
+        const hintPaths = aliases
+            .flatMap((alias) => [
+            join(homedir(), ".codex", "skills", alias, "SKILL.md"),
+            join(homedir(), ".agents", "skills", alias, "SKILL.md"),
+        ])
+            .filter(Boolean);
+        return {
+            skill: normalized,
+            hintPaths: Array.from(new Set(hintPaths)),
+        };
+    })
+        .filter((entry) => entry.skill.length > 0);
+}
+export function buildSliceOutputInstructions(input) {
+    const skillHints = buildSkillHints(input.requiredSkills);
+    return [
+        "# Slice Execution",
+        "",
+        `Slice run: ${input.runId}`,
+        "",
+        "Reporting:",
+        "- You MUST emit progress at least twice (start + completion) using an OrgX progress tool.",
+        "- Preferred tool: orgx_report_progress. Equivalent aliases are valid (for example mcp__orgx__update_stream_progress).",
+        "- If no OrgX progress tool is available, include a blocking decisions_needed entry describing the missing tool.",
+        "- Do NOT hunt for OrgX mutation tools to mark tasks done. Instead, request status changes in your FINAL JSON via task_updates/milestone_updates; the coordinator will apply them.",
+        "",
+        "What to do:",
+        "- Choose a coherent slice of work you can complete end-to-end in this run.",
+        "- Execute the work (code/docs/config) and produce verifiable outcomes.",
+        "- Self-assess confidence when saving artifacts and include `confidence_score` in [0,1].",
+        "- If blocked, be explicit about what decision/info is required.",
+        "- Keep this run focused: stay inside the current repository/workdir and avoid unrelated exploration.",
+        "- Execution budget: prefer <=12 shell commands and <=6 minutes wall time.",
+        "- Verification budget: run only targeted checks for changed files. Avoid full-suite commands (for example `npm run test:hooks`, `npm test`, `npm run build`) unless the task explicitly requires them.",
+        "- If you hit sandbox/env blockers after one retry, stop and return `status=needs_decision` with the blocker and the smallest unblocking action.",
+        "- For each required skill, read the skill document and collect proof (path + sha256 + heading).",
+        "",
+        "Output requirements:",
+        "- Print ONLY a single JSON object as the final output (no interim JSON status messages).",
+        `- Your JSON MUST conform to this schema file: ${input.schemaPath}`,
+        "- Artifacts must be verifiable: include URLs or local paths, plus verification steps.",
+        "- Include `confidence_score` for each artifact (`0` to `1`; use `null` when unknown).",
+        "- If you need a human decision, include it in decisions_needed.",
+        "- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).",
+        "- If status is blocked, needs_decision, or error: include at least one decisions_needed entry with blocking=true.",
+        "- Status/decision consistency is strict:",
+        "  - If any decision is blocking=true, status MUST be needs_decision or blocked (never completed).",
+        "  - Only use status=completed when all listed decisions are non-blocking follow-ups.",
+        "- Never return status=completed with zero artifacts and zero task/milestone updates.",
+        "- skill_evidence is mandatory. Include one object per required skill with:",
+        "  - skill (exact required skill id without leading $)",
+        "  - skill_file (absolute SKILL.md path used)",
+        "  - skill_sha256 (lowercase SHA-256 hex of that file)",
+        "  - skill_heading (first markdown heading or first non-empty line)",
+        "- If you cannot locate/verify a required skill file, return status=needs_decision and a blocking decisions_needed entry.",
+        "Skill file hints:",
+        ...(skillHints.length > 0
+            ? skillHints.flatMap((entry) => [
+                `- ${entry.skill}:`,
+                ...entry.hintPaths.map((path) => `  - ${path}`),
+            ])
+            : ["- (none)"]),
+        "- If you are confident OrgX statuses should change, include task_updates and/or milestone_updates (with a short reason).",
+        "  - task_updates.status must be one of: todo, in_progress, done, blocked",
+        "  - milestone_updates.status must be one of: planned, in_progress, completed, at_risk, cancelled",
+    ].join("\n");
+}
 export function buildWorkstreamSlicePrompt(input) {
+    const skillHints = buildSkillHints(input.executionPolicy.requiredSkills);
     const milestones = input.milestoneSummaries
         .map((m) => `- ${m.title} (${m.status}) [${m.id}]`)
         .slice(0, 10)
@@ -435,8 +795,25 @@ export function buildWorkstreamSlicePrompt(input) {
     })
         .slice(0, 18)
         .join("\n");
+    const behaviorConfigLines = [
+        input.behaviorConfig?.configId
+            ? `- behavior_config_id: ${input.behaviorConfig.configId}`
+            : null,
+        input.behaviorConfig?.version
+            ? `- behavior_config_version: ${input.behaviorConfig.version}`
+            : null,
+        input.behaviorConfig?.hash
+            ? `- behavior_config_hash: ${input.behaviorConfig.hash}`
+            : null,
+        input.behaviorConfig?.policySource
+            ? `- policy_source: ${input.behaviorConfig.policySource}`
+            : null,
+        input.behaviorConfig?.context
+            ? `- behavior_context: ${input.behaviorConfig.context}`
+            : null,
+    ].filter((line) => Boolean(line));
     return [
-        "You are an OrgX execution agent running ONE workstream slice in a background codex session.",
+        "You are an OrgX execution agent running ONE workstream slice in a background autonomous session.",
         "",
         `Execution policy: ${input.executionPolicy.domain}`,
         `Required skills: ${input.executionPolicy.requiredSkills.map((s) => (s.startsWith("$") ? s : `$${s}`)).join(", ")}`,
@@ -444,6 +821,13 @@ export function buildWorkstreamSlicePrompt(input) {
         `Initiative: ${input.initiativeTitle} [${input.initiativeId}]`,
         `Workstream: ${input.workstreamTitle} [${input.workstreamId}]`,
         `Slice run: ${input.runId}`,
+        ...(behaviorConfigLines.length > 0
+            ? [
+                "",
+                "Behavior config (plugin-injected context):",
+                ...behaviorConfigLines,
+            ]
+            : []),
         "",
         "Milestones (context):",
         milestones || "- (none found)",
@@ -452,25 +836,62 @@ export function buildWorkstreamSlicePrompt(input) {
         tasks || "- (none found)",
         "",
         "Reporting:",
-        "- Prefer using the MCP tool orgx_report_progress for progress updates (if it is available in your tool list).",
+        "- You MUST emit progress at least twice (start + completion) using an OrgX progress tool.",
+        "- Preferred tool: orgx_report_progress. Equivalent aliases are valid (for example mcp__orgx__update_stream_progress).",
+        "- If no OrgX progress tool is available, include a blocking decisions_needed entry describing the missing tool.",
         "- Do NOT hunt for OrgX mutation tools to mark tasks done. Instead, request status changes in your FINAL JSON via task_updates/milestone_updates; the coordinator will apply them.",
         "",
         "What to do:",
         "- Choose a coherent slice of work you can complete end-to-end in this run.",
         "- Execute the work (code/docs/config) and produce verifiable outcomes.",
+        "- Self-assess confidence when saving artifacts and include `confidence_score` in [0,1].",
         "- If blocked, be explicit about what decision/info is required.",
+        "- Keep this run focused: stay inside the current repository/workdir and avoid unrelated exploration.",
+        "- Execution budget: prefer <=12 shell commands and <=6 minutes wall time.",
+        "- Verification budget: run only targeted checks for changed files. Avoid full-suite commands (for example `npm run test:hooks`, `npm test`, `npm run build`) unless the task explicitly requires them.",
+        "- If you hit sandbox/env blockers after one retry, stop and return `status=needs_decision` with the blocker and the smallest unblocking action.",
+        "- For each required skill, read the skill document and collect proof (path + sha256 + heading).",
         "",
         "Output requirements:",
-        "- Print ONLY a single JSON object as the final output.",
+        "- Print ONLY a single JSON object as the final output (no interim JSON status messages).",
         `- Your JSON MUST conform to this schema file: ${input.schemaPath}`,
         "- Artifacts must be verifiable: include URLs or local paths, plus verification steps.",
+        "- Include `confidence_score` for each artifact (`0` to `1`; use `null` when unknown).",
         "- If you need a human decision, include it in decisions_needed.",
         "- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).",
+        "- If status is blocked, needs_decision, or error: include at least one decisions_needed entry with blocking=true.",
         "- Status/decision consistency is strict:",
         "  - If any decision is blocking=true, status MUST be needs_decision or blocked (never completed).",
         "  - Only use status=completed when all listed decisions are non-blocking follow-ups.",
+        "- Never return status=completed with zero artifacts and zero task/milestone updates.",
+        "- skill_evidence is mandatory. Include one object per required skill with:",
+        "  - skill (exact required skill id without leading $)",
+        "  - skill_file (absolute SKILL.md path used)",
+        "  - skill_sha256 (lowercase SHA-256 hex of that file)",
+        "  - skill_heading (first markdown heading or first non-empty line)",
+        "- If you cannot locate/verify a required skill file, return status=needs_decision and a blocking decisions_needed entry.",
+        "Skill file hints:",
+        ...(skillHints.length > 0
+            ? skillHints.flatMap((entry) => [
+                `- ${entry.skill}:`,
+                ...entry.hintPaths.map((path) => `  - ${path}`),
+            ])
+            : ["- (none)"]),
         "- If you are confident OrgX statuses should change, include task_updates and/or milestone_updates (with a short reason).",
         "  - task_updates.status must be one of: todo, in_progress, done, blocked",
         "  - milestone_updates.status must be one of: planned, in_progress, completed, at_risk, cancelled",
     ].join("\n");
 }
+export function buildScopeDirective(scope, meta) {
+    switch (scope) {
+        case "milestone":
+            return (`You are completing milestone "${meta.milestoneTitles?.[0] ?? "Unknown"}" ` +
+                `(${meta.taskCount} tasks). Complete all tasks to close the milestone. Report per-task progress.`);
+        case "workstream":
+            return (`You are advancing the entire "${meta.workstreamTitle ?? "Unknown"}" workstream ` +
+                `(${meta.taskCount} tasks across ${meta.milestoneTitles?.length ?? 0} milestones). ` +
+                `Prioritize by dependency order. Report per-milestone progress.`);
+        default:
+            return "";
+    }
+}