@deftai/directive-core 0.95.0 → 0.97.0

package/dist/doctor/openclaw-soft-rebind.js

@@ -0,0 +1,164 @@
+/**
+ * Doctor check + --fix wire for OpenClaw soft AGENTS re-bind skill (#3171).
+ *
+ * Complements always-pins (#3001/#3008) and L2 product commands (#3064). This
+ * skill is the required durable soft post-amnesia surface for OpenClaw — not
+ * claimed via file-host PreCompact hooks alone.
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { formatOpenClawSoftRebindSkillMarkdown, isManagedOpenClawSoftRebindSkill, OPENCLAW_SOFT_REBIND_SKILL_ID, } from "../session/compact-ritual.js";
+import { assessOpenClawSoftRebindSkill, depositOpenClawSoftRebindSkill, } from "../session/openclaw-soft-rebind-deposit.js";
+import { detectOpenClaw, listInScopeSkillsDirs } from "./openclaw-skills.js";
+/** Stable doctor check id for JSON findings. */
+export const OPENCLAW_SOFT_REBIND_CHECK = "openclaw-soft-agents-rebind";
+const DOC_OPENCLAW_HOST = "docs/openclaw-agent-host.md";
+const REMEDIATION_FIX = "deft doctor --fix";
+function defaultIsDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function assessGaps(skillsDirs) {
+    const expected = formatOpenClawSoftRebindSkillMarkdown();
+    const missing = [];
+    const stale = [];
+    let present = 0;
+    for (const skillsDir of skillsDirs) {
+        const path = join(skillsDir, OPENCLAW_SOFT_REBIND_SKILL_ID, "SKILL.md");
+        if (!existsSync(path)) {
+            missing.push(`${skillsDir}/${OPENCLAW_SOFT_REBIND_SKILL_ID}`);
+            continue;
+        }
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch {
+            missing.push(`${skillsDir}/${OPENCLAW_SOFT_REBIND_SKILL_ID}`);
+            continue;
+        }
+        // Unmanaged content at the required slug is incomplete health, not pass
+        // (Greptile P1 #3171). Doctor --fix overwrites via deposit.
+        if (!isManagedOpenClawSoftRebindSkill(raw) || raw !== expected) {
+            stale.push(`${skillsDir}/${OPENCLAW_SOFT_REBIND_SKILL_ID}`);
+            continue;
+        }
+        present += 1;
+    }
+    return { missing, stale, present };
+}
+/**
+ * Doctor check: OpenClaw soft AGENTS re-bind skill present and current.
+ * No-ops when OpenClaw is not detected. Fix mode deposits managed skill.
+ */
+export function runOpenClawSoftRebindCheck(sink, addFinding, options) {
+    const seams = options.seams ?? {};
+    const env = seams.openclawEnv ?? process.env;
+    const homeDirFn = seams.openclawHomeDir ?? (() => homedir());
+    const isDir = seams.isDir ?? defaultIsDir;
+    const detect = detectOpenClaw(env, { homeDir: homeDirFn(), isDir });
+    if (!detect.detected) {
+        sink.info(`${OPENCLAW_SOFT_REBIND_CHECK}: skip -- OpenClaw not detected`);
+        addFinding({
+            severity: "skip",
+            message: "OpenClaw not detected",
+            check: OPENCLAW_SOFT_REBIND_CHECK,
+            status: "skip",
+            reason: "openclaw-not-detected",
+        });
+        return null;
+    }
+    const skillsDirs = listInScopeSkillsDirs(detect.stateDir, options.allAgents, {
+        isDir,
+    });
+    const gaps = assessGaps(skillsDirs);
+    if (gaps.missing.length === 0 && gaps.stale.length === 0) {
+        const scope = options.allAgents ? "main + workspace-* seats" : "main workspace";
+        const message = `${OPENCLAW_SOFT_REBIND_CHECK}: soft AGENTS re-bind skill present ` +
+            `(${OPENCLAW_SOFT_REBIND_SKILL_ID}) in ${scope}`;
+        sink.success(message);
+        addFinding({
+            severity: "skip",
+            message,
+            check: OPENCLAW_SOFT_REBIND_CHECK,
+            status: "present",
+            skill: OPENCLAW_SOFT_REBIND_SKILL_ID,
+            skills_dirs: skillsDirs,
+        });
+        return null;
+    }
+    if (options.fixMode) {
+        const depositResult = depositOpenClawSoftRebindSkill({
+            env,
+            homeDir: homeDirFn(),
+            allAgents: options.allAgents,
+            isDir,
+            skillsDirs,
+        });
+        const after = assessGaps(skillsDirs);
+        if (after.missing.length === 0 && after.stale.length === 0) {
+            const message = `${OPENCLAW_SOFT_REBIND_CHECK}: deposited soft AGENTS re-bind skill; ` +
+                `restart OpenClaw gateway or start a new session (${DOC_OPENCLAW_HOST})`;
+            sink.success(message);
+            addFinding({
+                severity: "skip",
+                message,
+                check: OPENCLAW_SOFT_REBIND_CHECK,
+                status: "fixed",
+                written: depositResult.writtenPaths,
+            });
+            return depositResult;
+        }
+        // Partial fix: report remaining gaps from post-deposit assessment (SLizard P2).
+        const partsAfter = [];
+        if (after.missing.length > 0) {
+            partsAfter.push(`missing=${after.missing.join(", ")}`);
+        }
+        if (after.stale.length > 0) {
+            partsAfter.push(`stale=${after.stale.join(", ")}`);
+        }
+        const messageAfter = `${OPENCLAW_SOFT_REBIND_CHECK}: OpenClaw soft AGENTS re-bind skill incomplete after fix ` +
+            `(${partsAfter.join("; ")}). Remediation: ${REMEDIATION_FIX} — see ${DOC_OPENCLAW_HOST}`;
+        sink.warn(messageAfter);
+        addFinding({
+            severity: "warning",
+            message: messageAfter,
+            check: OPENCLAW_SOFT_REBIND_CHECK,
+            status: "incomplete",
+            missing: after.missing,
+            stale: after.stale,
+            written: depositResult.writtenPaths,
+            suggestion: REMEDIATION_FIX,
+            docs: [DOC_OPENCLAW_HOST],
+        });
+        return depositResult;
+    }
+    const parts = [];
+    if (gaps.missing.length > 0) {
+        parts.push(`missing=${gaps.missing.join(", ")}`);
+    }
+    if (gaps.stale.length > 0) {
+        parts.push(`stale=${gaps.stale.join(", ")}`);
+    }
+    const message = `${OPENCLAW_SOFT_REBIND_CHECK}: OpenClaw soft AGENTS re-bind skill incomplete ` +
+        `(${parts.join("; ")}). Remediation: ${REMEDIATION_FIX} — see ${DOC_OPENCLAW_HOST}`;
+    sink.warn(message);
+    addFinding({
+        severity: "warning",
+        message,
+        check: OPENCLAW_SOFT_REBIND_CHECK,
+        status: "incomplete",
+        missing: gaps.missing,
+        stale: gaps.stale,
+        suggestion: REMEDIATION_FIX,
+        docs: [DOC_OPENCLAW_HOST],
+    });
+    return null;
+}
+export { assessOpenClawSoftRebindSkill, depositOpenClawSoftRebindSkill };
+//# sourceMappingURL=openclaw-soft-rebind.js.map

package/dist/hooks/dispatcher.d.ts

@@ -140,7 +140,8 @@ export declare function decideHook(input: HookDispatchInput, seams?: HookPolicyS
  * Cursor deposits use `failClosed: true`. Cursor treats empty/null stdout as a
  * hook failure and blocks the tool — so Cursor allows must emit explicit
  * `{"permission":"allow"}`. Other hosts keep empty allow so the host permission
- * flow is unchanged.
+ * flow is unchanged — except session.start / session.compact soft re-bind
+ * injection (#3171), which surfaces checklist text without a write tool.
  *
  * Cursor stdout always includes `code` (stable machine-readable decision code)
  * so agents can distinguish policy denials from host-integration failures

package/dist/hooks/dispatcher.js

@@ -7,6 +7,7 @@ import { evaluateIntentCeilingFromEnv } from "../policy/intent-ceiling.js";
 import { detectNoDeftDirective, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, } from "../policy/no-deft-directive.js";
 import { classifyMcpTool, DEFAULT_RUNTIME_AUTHORITY_POLICY, evaluateRuntimeAuthorityDirectWrite, evaluateRuntimeAuthorityShellOp, listShellOps, loadRuntimeAuthorityFromProject, } from "../policy/runtime-authority.js";
 import { loadStoryWriteFenceFromPath, resolveWriteFence } from "../policy/write-fence.js";
+import { appendSoftAgentsRebindToMessage, decisionCarriesSoftAgentsRebind, formatSoftAgentsRebindChecklist, } from "../session/compact-ritual.js";
 import { detectBranch } from "../session/git.js";
 import { emitSessionRitualBlockedProcessCost } from "../session/process-cost.js";
 import { markRitualStaleAfterCompact } from "../session/ritual-sentinel.js";
@@ -716,7 +717,8 @@ export function decideHook(input, seams = {}) {
                     host: input.host,
                     toolName: null,
                     projectRoot,
-                    message: result.message,
+                    // Soft checklist still surfaces after compact even when ritual was absent (#3171).
+                    message: appendSoftAgentsRebindToMessage(result.message),
                     scopePath: null,
                 };
             }
@@ -727,7 +729,7 @@ export function decideHook(input, seams = {}) {
                 host: input.host,
                 toolName: null,
                 projectRoot,
-                message: result.message,
+                message: appendSoftAgentsRebindToMessage(result.message),
                 scopePath: null,
             };
         }
@@ -739,8 +741,8 @@ export function decideHook(input, seams = {}) {
                 host: input.host,
                 toolName: null,
                 projectRoot,
-                message: "Directive compact re-arm bookkeeping failed on its non-blocking path: " +
-                    `${String(cause)}`,
+                message: appendSoftAgentsRebindToMessage("Directive compact re-arm bookkeeping failed on its non-blocking path: " +
+                    `${String(cause)}`),
                 scopePath: null,
             };
         }
@@ -775,8 +777,9 @@ export function decideHook(input, seams = {}) {
                     host: input.host,
                     toolName: null,
                     projectRoot,
-                    message: `Directive SessionStart bookkeeping reported exit ${result.code} on its non-blocking path` +
-                        `${detail.length > 0 ? `: ${detail}` : "."}`,
+                    // Best-effort soft cue on SessionStart (Codex gap + resume/amnesia) (#3171).
+                    message: appendSoftAgentsRebindToMessage(`Directive SessionStart bookkeeping reported exit ${result.code} on its non-blocking path` +
+                        `${detail.length > 0 ? `: ${detail}` : "."}`),
                     scopePath: null,
                 };
             }
@@ -789,7 +792,7 @@ export function decideHook(input, seams = {}) {
                 host: input.host,
                 toolName: null,
                 projectRoot,
-                message: `Directive SessionStart bookkeeping failed on its non-blocking path: ${String(cause)}`,
+                message: appendSoftAgentsRebindToMessage(`Directive SessionStart bookkeeping failed on its non-blocking path: ${String(cause)}`),
                 scopePath: null,
             };
         }
@@ -800,7 +803,8 @@ export function decideHook(input, seams = {}) {
             host: input.host,
             toolName: null,
             projectRoot,
-            message: "SessionStart bookkeeping completed on a non-blocking path.",
+            // Soft AGENTS re-bind on SessionStart without requiring a write tool (#3171 / #2769).
+            message: appendSoftAgentsRebindToMessage("SessionStart bookkeeping completed on a non-blocking path."),
             scopePath: null,
         };
     }
@@ -881,13 +885,27 @@ export function decideHook(input, seams = {}) {
     }
     return inspectMutationGates(input, toolName, seams, { proposedLifecycleExempt: true });
 }
+/**
+ * Soft AGENTS re-bind text for host injection when decision carries soft path (#3171).
+ * Prefer the checklist portion of the decision message; fall back to SoT formatter.
+ */
+function softAgentsRebindWireText(decision) {
+    if (!decisionCarriesSoftAgentsRebind({ event: decision.event, code: decision.code })) {
+        return null;
+    }
+    if (decision.message.includes("Soft AGENTS re-bind checklist:")) {
+        return decision.message;
+    }
+    return formatSoftAgentsRebindChecklist();
+}
 /**
  * Render host-facing hook output.
  *
  * Cursor deposits use `failClosed: true`. Cursor treats empty/null stdout as a
  * hook failure and blocks the tool — so Cursor allows must emit explicit
  * `{"permission":"allow"}`. Other hosts keep empty allow so the host permission
- * flow is unchanged.
+ * flow is unchanged — except session.start / session.compact soft re-bind
+ * injection (#3171), which surfaces checklist text without a write tool.
  *
  * Cursor stdout always includes `code` (stable machine-readable decision code)
  * so agents can distinguish policy denials from host-integration failures
@@ -896,9 +914,45 @@ export function decideHook(input, seams = {}) {
  */
 export function renderHostDecision(host, decision) {
     if (decision.verdict === "allow") {
+        const soft = softAgentsRebindWireText(decision);
         if (host === "cursor") {
+            if (decision.event === "session.start" && soft !== null) {
+                // Cursor sessionStart injects additional_context into the conversation.
+                return JSON.stringify({
+                    permission: "allow",
+                    code: decision.code,
+                    additional_context: soft,
+                });
+            }
+            if (decision.event === "session.compact" && soft !== null) {
+                // Cursor preCompact is observational; user_message surfaces the soft cue.
+                // Hard re-arm still ran via bookkeeping; agent path also gets SessionStart on resume.
+                return JSON.stringify({
+                    user_message: soft,
+                    code: decision.code,
+                });
+            }
             return JSON.stringify({ permission: "allow", code: decision.code });
         }
+        if (soft !== null &&
+            (decision.event === "session.start" || decision.event === "session.compact")) {
+            if (host === "claude" || host === "codex") {
+                const hookEventName = decision.event === "session.start" ? "SessionStart" : "PostCompact";
+                return JSON.stringify({
+                    hookSpecificOutput: {
+                        hookEventName,
+                        additionalContext: soft,
+                    },
+                });
+            }
+            if (host === "grok") {
+                return JSON.stringify({
+                    decision: "allow",
+                    reason: soft,
+                    additional_context: soft,
+                });
+            }
+        }
         return "";
     }
     switch (host) {

package/dist/index.d.ts

@@ -14,7 +14,9 @@ export * as branch from "./branch/index.js";
 export * as cache from "./cache/index.js";
 export * as capacity from "./capacity/index.js";
 export * as codebase from "./codebase/index.js";
+export * as consumerCheckContract from "./consumer-check-contract/index.js";
 export * from "./coverage-hotspots/index.js";
+export * as deliveryAttempt from "./delivery-attempt/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
 export * as escalation from "./escalation/index.js";
@@ -35,6 +37,7 @@ export * as lifecycle from "./lifecycle/index.js";
 export * as metrics from "./metrics/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";
+export * as parentTurnShape from "./parent-turn-shape/index.js";
 export * as platform from "./platform/index.js";
 export * as policy from "./policy/index.js";
 export * as prClosingKeywords from "./pr-closing-keywords/index.js";
@@ -51,11 +54,13 @@ export * as render from "./render/index.js";
 export * as resolution from "./resolution/index.js";
 export * as scm from "./scm/index.js";
 export * as scope from "./scope/index.js";
+export * as scopeProvenance from "./scope-provenance/index.js";
 export * as session from "./session/index.js";
 export * as slash from "./slash/index.js";
 export * as slice from "./slice/index.js";
 export * as storyReady from "./story-ready/index.js";
 export * as swarm from "./swarm/index.js";
+export * as testBoundary from "./test-boundary/index.js";
 export * as toolEvents from "./tool-events/index.js";
 export * as triage from "./triage/index.js";
 export * as userConfig from "./user-config/index.js";

package/dist/index.js

@@ -14,7 +14,9 @@ export * as branch from "./branch/index.js";
 export * as cache from "./cache/index.js";
 export * as capacity from "./capacity/index.js";
 export * as codebase from "./codebase/index.js";
+export * as consumerCheckContract from "./consumer-check-contract/index.js";
 export * from "./coverage-hotspots/index.js";
+export * as deliveryAttempt from "./delivery-attempt/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
 export * as escalation from "./escalation/index.js";
@@ -36,6 +38,7 @@ export * as lifecycle from "./lifecycle/index.js";
 export * as metrics from "./metrics/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";
+export * as parentTurnShape from "./parent-turn-shape/index.js";
 export * as platform from "./platform/index.js";
 export * as policy from "./policy/index.js";
 export * as prClosingKeywords from "./pr-closing-keywords/index.js";
@@ -52,11 +55,13 @@ export * as render from "./render/index.js";
 export * as resolution from "./resolution/index.js";
 export * as scm from "./scm/index.js";
 export * as scope from "./scope/index.js";
+export * as scopeProvenance from "./scope-provenance/index.js";
 export * as session from "./session/index.js";
 export * as slash from "./slash/index.js";
 export * as slice from "./slice/index.js";
 export * as storyReady from "./story-ready/index.js";
 export * as swarm from "./swarm/index.js";
+export * as testBoundary from "./test-boundary/index.js";
 export * as toolEvents from "./tool-events/index.js";
 export * as triage from "./triage/index.js";
 export * as userConfig from "./user-config/index.js";

package/dist/init-deposit/gitignore.js

@@ -37,6 +37,11 @@ export const CANONICAL_GITIGNORE_BASELINE = [
     "vbrief/.triage-cache/scope-lifecycle.jsonl",
     "vbrief/.triage-cache/decompositions/",
     "vbrief/.triage-cache/doctor-state.json",
+    // Per-clone session state (#3146): throttle / release-availability JSON
+    // written under the lifecycle .triage-cache; selective ignore only (hybrid
+    // #1144 — never blanket-ignore the whole .triage-cache directory).
+    "vbrief/.triage-cache/staleness-tickler-state.json",
+    "vbrief/.triage-cache/release-availability-state.json",
     // Symmetric `xbrief/` layout entries (#2348). On the migrated `xbrief/` tree
     // the engine writes operator-private triage-cache files to
     // `xbrief/.triage-cache/`; without these the paths are trackable, violating
@@ -47,6 +52,8 @@ export const CANONICAL_GITIGNORE_BASELINE = [
     "xbrief/.triage-cache/scope-lifecycle.jsonl",
     "xbrief/.triage-cache/decompositions/",
     "xbrief/.triage-cache/doctor-state.json",
+    "xbrief/.triage-cache/staleness-tickler-state.json",
+    "xbrief/.triage-cache/release-availability-state.json",
     "vbrief/*.lock",
     ".deft/core.bak-*/",
     ".deft/*.bak-*",

package/dist/init-deposit/hygiene.d.ts

@@ -8,7 +8,7 @@
  * and scope briefs are never installer-managed; if they reappear in
  * `installerManagedMatchers()`, unit tests and deposit-time assert fail closed.
  *
- * Refs #1576, #1453, #1430, #3029, #3030.
+ * Refs #1576, #1453, #1430, #3029, #3030, #3127, #3117.
  */
 import { type InitDepositIo } from "./constants.js";
 export declare const CODEQL_CONFIG_REL = ".github/codeql/codeql-config.yml";

package/dist/init-deposit/hygiene.js

@@ -8,7 +8,7 @@
  * and scope briefs are never installer-managed; if they reappear in
  * `installerManagedMatchers()`, unit tests and deposit-time assert fail closed.
  *
- * Refs #1576, #1453, #1430, #3029, #3030.
+ * Refs #1576, #1453, #1430, #3029, #3030, #3127, #3117.
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, rmSync } from "node:fs";
@@ -82,6 +82,16 @@ export function installerManagedMatchers() {
         { exact: CODEQL_CONFIG_REL },
         { exact: CORE_GUARD_WORKFLOW_REL },
         { exact: "Taskfile.yml" },
+        // Upgrade co-travel unit (#3127): npm pin + lock follow-through and the
+        // freshness live stamp (#3117) are part of a normal framework upgrade, not
+        // product feature work. Path-level allow for v1 (stricter “only
+        // @deftai/directive version changed” is a follow-on if needed).
+        // Mixing .deft/core/** with true app/product paths still fails (#1430).
+        { exact: "package.json" },
+        { exact: "package-lock.json" },
+        { exact: "pnpm-lock.yaml" },
+        { exact: "yarn.lock" },
+        { exact: ".deft/GENERATION.json" },
         // Legacy vbrief/ tree -- retained for not-yet-migrated consumers.
         { exact: "vbrief/.deft-version" },
         { exact: "vbrief/vbrief.md" },
@@ -476,9 +486,11 @@ export function printCommitGuidance(io, paths, staged) {
     if (paths.length === 0)
         return;
     const addCmd = `git add ${paths.join(" ")}`;
-    io.printf("\nCommit hygiene (#1453, #1671): keep the framework deposit in its OWN branch/PR.\n");
-    io.printf("Do NOT use `git add -A` -- mixing the payload with your own files trips the\n");
+    io.printf("\nCommit hygiene (#1453, #1671, #3127): keep the framework upgrade in its OWN branch/PR.\n");
+    io.printf("Do NOT use `git add -A` -- mixing the payload with product/app files trips the\n");
     io.printf("deft-core-guard CI check.\n");
+    io.printf("One upgrade PR MAY co-travel: .deft/core/** + installer-managed deposits + package.json\n");
+    io.printf("pin/lock + .deft/GENERATION.json. True app/product paths still require a separate PR.\n");
     if (staged) {
         io.printf("The installer already staged ONLY these framework + installer-managed paths:\n");
         io.printf(`  ${addCmd}\n`);
@@ -488,7 +500,7 @@ export function printCommitGuidance(io, paths, staged) {
         io.printf(`  ${addCmd}\n`);
     }
     io.printf("Then take the framework deposit through the full PR lifecycle so deft-core-guard\n");
-    io.printf("evaluates a clean, standalone PR:\n");
+    io.printf("evaluates a clean, standalone upgrade PR:\n");
     io.printf(`  1. Branch: git switch -c ${COMMIT_HYGIENE_BRANCH_NAME}\n`);
     io.printf('  2. Commit: git commit -m "chore(deft): update framework payload"\n');
     io.printf(`  3. Push:   git push -u origin ${COMMIT_HYGIENE_BRANCH_NAME}\n`);

package/dist/init-deposit/init-deposit.js

@@ -15,6 +15,7 @@ import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { readCorePackageVersion } from "../engine-version.js";
 import { stampLiveGeneration } from "../freshness/generation.js";
 import { renderProjectDefinition } from "../render/project-render.js";
+import { depositOpenClawSoftRebindSkill } from "../session/openclaw-soft-rebind-deposit.js";
 import { depositOpenClawL2ProductCommands } from "../slash/openclaw-deposit.js";
 import { agentHookReadinessJson, evaluateAgentHookReadiness, evaluateAgentHookReadinessSafely, } from "../verify-env/agent-hook-readiness.js";
 import { removeStaleMigratedFrameworkNarrative } from "../xbrief-migrate/migrate-project.js";
@@ -201,6 +202,10 @@ export async function runInitDeposit(args, io, seams = {}) {
     writeConsumerGitHooks(projectDir, deftDir, io, seams.gitHooks);
     writeAgentHookDeposit(projectDir, io);
     writeSlashCommandDeposit(projectDir, io);
+    // #3171: OpenClaw soft AGENTS re-bind skill when OC signals present (fail-closed otherwise).
+    depositOpenClawSoftRebindSkill({
+    /* env defaults; skip when OpenClaw not detected */
+    });
     // #3064: OpenClaw L2 product-command skills when OC signals present (fail-closed otherwise).
     depositOpenClawL2ProductCommands({
         projectRoot: projectDir,

package/dist/init-deposit/refresh.js

@@ -22,6 +22,7 @@ import { resolveLifecycleRoot } from "../layout/resolve.js";
 import { detectNoDeftDirective, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY, } from "../policy/no-deft-directive.js";
 import { runOrgForceOnMigration } from "../policy/org-force-on-migration.js";
 import { checkLocalEngineIntegrity, classify, ENGINE_PACKAGE, plan, renderGlobalInstall, resolveEngine, } from "../resolution/index.js";
+import { depositOpenClawSoftRebindSkill } from "../session/openclaw-soft-rebind-deposit.js";
 import { depositOpenClawL2ProductCommands } from "../slash/openclaw-deposit.js";
 import { gitPorcelain } from "../story-ready/git.js";
 import { agentHookReadinessJson, evaluateAgentHookReadiness, evaluateAgentHookReadinessSafely, } from "../verify-env/agent-hook-readiness.js";
@@ -506,6 +507,8 @@ export async function runRefreshDeposit(args, io, seams = {}) {
     // #75 residual: multi-host thin skill discovery (mirror `.agents/skills` inventory).
     writeMultiHostSkillDiscovery(projectDir, io);
     writeSlashCommandDeposit(projectDir, io);
+    // #3171: OpenClaw soft AGENTS re-bind skill when OC signals present (fail-closed otherwise).
+    depositOpenClawSoftRebindSkill({});
     // #3064: OpenClaw L2 product-command skills when OC signals present (fail-closed otherwise).
     depositOpenClawL2ProductCommands({
         projectRoot: projectDir,

package/dist/init-deposit/scaffold.js

@@ -507,11 +507,12 @@ function coreGuardWorkflowContent() {
     const baseSha = githubActionsExpr("github.event.pull_request.base.sha");
     const headSha = githubActionsExpr("github.event.pull_request.head.sha");
     return ("name: deft-core-guard\n\n" +
-        "# Deft framework guard (#1430): a single PR should not mix changes to the\n" +
-        "# vendored framework payload (.deft/core/**) with changes to your own project\n" +
-        "# files. Framework updates come from `deft-install` / upgrade and should\n" +
-        "# land in their own PR so reviewers (and bot reviewers) can treat them as\n" +
-        "# packaged, machine-managed assets. Delete this file if you do not want the guard.\n" +
+        "# Deft framework guard (#1430 / #3127): a single PR should not mix changes to the\n" +
+        "# vendored framework payload (.deft/core/**) with true application/product files.\n" +
+        "# One upgrade PR MAY include deposit + installer-managed paths + package.json pin/lock\n" +
+        "# + .deft/GENERATION.json. Framework updates come from `deft update` / install and should\n" +
+        "# land without product feature work so reviewers treat the payload as machine-managed.\n" +
+        "# Delete this file if you do not want the guard.\n" +
         "on:\n" +
         "  pull_request:\n\n" +
         "permissions:\n" +

package/dist/parent-turn-shape/evaluate.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Parent turn-shape hard-stop for text-repetition hang (FC14 / #3131).
+ *
+ * Soft skill prose (#2943) alone is insufficient: parents still burn the full
+ * output budget on identical progress sentences with zero tool_use after leaf
+ * announce. This pure library is the Directive-side machine-checkable gate.
+ *
+ * Hosts (OpenClaw, swarm parents, review monitors) SHOULD evaluate the parent
+ * turn stream mid-generation and hard-stop when `ok` is false.
+ *
+ * Illegal shape (MUST NOT):
+ *   N > maxIdenticalWithoutTool (default 2) near-identical assistant sentences
+ *   (or streaming text chunks) in one turn with no tool_use and no yield.
+ *
+ * Legal post-announce shapes:
+ *   1. Tool batch (ground-truth) then one consolidate
+ *   2. sessions_yield / wait without filler
+ *   3. One short user answer that is NOT a repeated progress line
+ */
+/** Failure class codes for operator / host recovery surfaces. */
+export type ParentTurnFailClass = "none" | "FC14" | "text-repetition-hang" | "progress-only-no-tool";
+/** Ordered events observed within a single parent turn. */
+export type ParentTurnEvent = {
+    kind: "assistant_text";
+    text: string;
+} | {
+    kind: "tool_use";
+    name?: string;
+} | {
+    kind: "yield";
+};
+export interface ParentTurnShapeInput {
+    /** Ordered events from one parent turn (streaming deltas may be separate). */
+    readonly events: readonly ParentTurnEvent[];
+    /**
+     * When true, multi-sentence progress-only text with zero tools/yield is also
+     * illegal even without exact N>2 identity (post-`subagent_announce` policy).
+     */
+    readonly afterSubagentAnnounce?: boolean;
+    /**
+     * Max near-identical consecutive (or within-turn) text units allowed without
+     * tool_use / yield. Issue contract: MUST NOT emit N>2 → default max = 2.
+     */
+    readonly maxIdenticalWithoutTool?: number;
+}
+export interface ParentTurnShapeResult {
+    readonly ok: boolean;
+    /** Primary fail class (`FC14` aliases `text-repetition-hang`). */
+    readonly failClass: ParentTurnFailClass;
+    readonly reasons: readonly string[];
+    /** Highest count of near-identical text units observed without tool/yield. */
+    readonly maxIdenticalCount: number;
+    readonly hasToolUse: boolean;
+    readonly hasYield: boolean;
+}
+/** Canonical fail class for the hang (#3131 / soft FC14 recurrence of #2943). */
+export declare const PARENT_TURN_FAIL_FC14: "FC14";
+/** Default max identical text units without tool/yield (N>2 is illegal). */
+export declare const DEFAULT_MAX_IDENTICAL_WITHOUT_TOOL = 2;
+/**
+ * Normalize assistant text for identity comparison.
+ * Collapses whitespace, lowercases, strips common trailing punctuation.
+ */
+export declare function normalizeTurnText(text: string): string;
+/** Split a blob into sentence-like units (periods, newlines, ellipsis). */
+export declare function splitTextUnits(text: string): string[];
+/**
+ * True when two normalized strings are near-identical (exact, containment with
+ * high length ratio, or high word Jaccard). Short units never match.
+ */
+export declare function isNearIdentical(a: string, b: string): boolean;
+/**
+ * Detect when a single blob itself embeds the same sentence many times
+ * (model streams one giant assistant message of repeated lines).
+ */
+export declare function countRepeatedUnitsInBlob(text: string): number;
+/**
+ * Evaluate whether a parent turn shape is legal under the FC14 hard-stop.
+ * Pure / side-effect free — safe for mid-stream host gates and unit tests.
+ */
+export declare function evaluateParentTurnShape(input: ParentTurnShapeInput): ParentTurnShapeResult;
+/** Convenience: true when the turn is an illegal text-repetition hang. */
+export declare function isTextRepetitionHang(input: ParentTurnShapeInput): boolean;
+//# sourceMappingURL=evaluate.d.ts.map