project-tiny-context-harness 0.8.11 → 0.8.12

package/dist/long-task-hook.js

@@ -1,13 +1,41 @@
 #!/usr/bin/env node
 import { readActiveLongTaskBinding } from "./lib/long-task-state.js";
 import { stopCheckDeliveryTask } from "./lib/long-task-status-v2.js";
+import { LONG_TASK_IMPLEMENTATION_AGENT, selectedAgentType, } from "./lib/long-task-worker-selection.js";
 import { repositoryRoot } from "./lib/long-task-workspace.js";
+const LONG_TASK_IMPLEMENTATION_BOUNDARY = [
+    "This is a delegated rolling implementation worker, not the parent Long-Task Goal.",
+    "Follow only the bounded packet from the parent.",
+    "Do not run long-task resume, Preflight, Compile, Authority Revision, verify as formal Progress, Final Gate, Stop/close, abandon, or completion.",
+    "The parent Goal owns Source, Contract, Authority, Context writeback, integration and formal acceptance.",
+    "Your report is advisory and is not Progress, Evidence or acceptance.",
+].join("\n");
+const AGENT_SPAWN_TOOLS = new Set(["spawn_agent", "Agent"]);
+const EXACT_WORKER_REQUIRED = "Active Tiny Context Long-Task permits delegation only to the exact custom agent long_task_implementation. The current host request does not explicitly select it. Do not substitute a generic worker; complete this packet in the parent Goal.";
 const input = await readStdin();
+const isAgentSpawnPreToolUse = input.hook_event_name === "PreToolUse" &&
+    AGENT_SPAWN_TOOLS.has(input.tool_name ?? "");
+if (input.hook_event_name === "PreToolUse" && !isAgentSpawnPreToolUse)
+    output({});
 try {
     const root = await repositoryRoot(input.cwd || process.cwd());
     const active = await readActiveLongTaskBinding(root);
     if (!active)
         output({});
+    if (isAgentSpawnPreToolUse) {
+        if (selectedAgentType(input.tool_input) === LONG_TASK_IMPLEMENTATION_AGENT)
+            output({});
+        denyAgentSpawn(EXACT_WORKER_REQUIRED);
+    }
+    if (input.hook_event_name === "SubagentStart")
+        output(input.agent_type === LONG_TASK_IMPLEMENTATION_AGENT
+            ? {
+                hookSpecificOutput: {
+                    hookEventName: "SubagentStart",
+                    additionalContext: LONG_TASK_IMPLEMENTATION_BOUNDARY,
+                },
+            }
+            : {});
     if (input.hook_event_name === "SessionStart" ||
         input.hook_event_name === "PostCompact")
         output({
@@ -35,7 +63,9 @@ try {
     });
 }
 catch (error) {
-    const reason = `Long-task Live Final Gate failed closed: ${message(error)}`;
+    const reason = `Tiny Context Long-Task Hook failed closed: ${message(error)}`;
+    if (isAgentSpawnPreToolUse)
+        denyAgentSpawn(`${reason} Do not spawn a substitute agent; complete the packet in the parent Goal.`);
     if (input.hook_event_name === "Stop")
         output({ decision: "block", reason });
     output({ continue: false, stopReason: reason });
@@ -50,6 +80,15 @@ function output(value) {
     process.stdout.write(`${JSON.stringify(value)}\n`);
     process.exit(0);
 }
+function denyAgentSpawn(reason) {
+    output({
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    });
+}
 function message(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/public-types.d.ts

@@ -0,0 +1,8 @@
+export type { HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./lib/types.js";
+export type { CheckExecutionResultV2, CompiledDeliveryContractV2, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, } from "./lib/long-task-delivery-types.js";
+export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, } from "./lib/long-task-boundary-check.js";
+export type { DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, } from "./lib/design-resource-handoff-bundle.js";
+export type { DesignResourceHandoffPreflightV1, DesignResourceHandoffV1, } from "./lib/design-resource-handoff-types.js";
+export type { DesignResourceHandoffPreflightV2, DesignResourceHandoffV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, } from "./lib/design-resource-symbolic-fact-types.js";
+export type { DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, } from "./lib/design-resource-symbolic-source-ir-types.js";
+export type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, } from "./lib/symbolic-denotation-types.js";

package/dist/public-types.js

@@ -0,0 +1 @@
+export {};

package/dist/schemas/design-resource-symbolic-noninterference-artifact-v2.schema.json

@@ -0,0 +1,289 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://github.com/Seven128/project-tiny-context-harness/schemas/design-resource-symbolic-noninterference-artifact-v2.schema.json",
+    "title": "Project Tiny Context Symbolic Non-Interference Artifact v2",
+    "type": "object",
+    "additionalProperties": false,
+    "required": [
+        "schema_version",
+        "side",
+        "method",
+        "oracle_identity",
+        "oracle_version",
+        "oracle_implementation_sha256",
+        "oracle_capability",
+        "environment_sha256",
+        "input_resources",
+        "input_snapshot_sha256",
+        "source_manifest_snapshot_sha256",
+        "target_snapshot_sha256",
+        "certificate_scope_sha256",
+        "rule_scope_sha256",
+        "omitted_axis_refs",
+        "derived_result",
+        "method_result_sha256",
+        "verdict",
+        "failure_witness"
+    ],
+    "properties": {
+        "schema_version": {
+            "const": "design-resource-symbolic-noninterference-artifact-v2"
+        },
+        "side": { "enum": ["source", "production"] },
+        "method": { "$ref": "#/$defs/method" },
+        "oracle_identity": { "$ref": "#/$defs/nonemptyString" },
+        "oracle_version": { "$ref": "#/$defs/nonemptyString" },
+        "oracle_implementation_sha256": { "$ref": "#/$defs/sha256" },
+        "oracle_capability": { "$ref": "#/$defs/nonemptyString" },
+        "environment_sha256": { "$ref": "#/$defs/sha256" },
+        "input_resources": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#/$defs/inputBinding" }
+        },
+        "input_snapshot_sha256": { "$ref": "#/$defs/sha256" },
+        "source_manifest_snapshot_sha256": {
+            "oneOf": [{ "$ref": "#/$defs/sha256" }, { "type": "null" }]
+        },
+        "target_snapshot_sha256": { "$ref": "#/$defs/sha256" },
+        "certificate_scope_sha256": { "$ref": "#/$defs/sha256" },
+        "rule_scope_sha256": { "$ref": "#/$defs/sha256" },
+        "omitted_axis_refs": {
+            "type": "array",
+            "uniqueItems": true,
+            "items": { "$ref": "#/$defs/stableKey" }
+        },
+        "derived_result": { "$ref": "#/$defs/derivedResult" },
+        "method_result_sha256": { "$ref": "#/$defs/sha256" },
+        "verdict": { "enum": ["passed", "failed"] },
+        "failure_witness": {
+            "oneOf": [{ "$ref": "#/$defs/failureWitness" }, { "type": "null" }]
+        }
+    },
+    "allOf": [
+        {
+            "if": {
+                "properties": { "side": { "const": "source" } },
+                "required": ["side"]
+            },
+            "then": {
+                "properties": {
+                    "source_manifest_snapshot_sha256": { "$ref": "#/$defs/sha256" }
+                }
+            },
+            "else": {
+                "properties": {
+                    "source_manifest_snapshot_sha256": { "type": "null" }
+                }
+            }
+        },
+        {
+            "if": {
+                "properties": { "verdict": { "const": "passed" } },
+                "required": ["verdict"]
+            },
+            "then": { "properties": { "failure_witness": { "type": "null" } } },
+            "else": {
+                "properties": {
+                    "failure_witness": { "$ref": "#/$defs/failureWitness" }
+                }
+            }
+        }
+    ],
+    "$defs": {
+        "nonemptyString": { "type": "string", "minLength": 1 },
+        "stableKey": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "^[a-z0-9][a-z0-9._-]*$"
+        },
+        "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "method": {
+            "enum": [
+                "closed_world_static_dependency_closure",
+                "restricted_ir_symbolic_equivalence",
+                "finite_complete_domain_exhaustive_equivalence"
+            ]
+        },
+        "scalar": {
+            "oneOf": [{ "type": "string" }, { "type": "number" }]
+        },
+        "inputBinding": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["resource_ref", "path", "declared_sha256", "current_sha256"],
+            "properties": {
+                "resource_ref": { "$ref": "#/$defs/stableKey" },
+                "path": { "$ref": "#/$defs/nonemptyString" },
+                "declared_sha256": { "$ref": "#/$defs/sha256" },
+                "current_sha256": { "$ref": "#/$defs/sha256" }
+            }
+        },
+        "dependencyNode": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "key",
+                "axis_refs",
+                "dependency_refs",
+                "input_resource_refs"
+            ],
+            "properties": {
+                "key": { "$ref": "#/$defs/stableKey" },
+                "axis_refs": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "items": { "$ref": "#/$defs/stableKey" }
+                },
+                "dependency_refs": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "items": { "$ref": "#/$defs/stableKey" }
+                },
+                "input_resource_refs": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "items": { "$ref": "#/$defs/stableKey" }
+                }
+            }
+        },
+        "dependencyRoot": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["fact_rule_refs", "node_ref"],
+            "properties": {
+                "fact_rule_refs": {
+                    "oneOf": [
+                        {
+                            "type": "array",
+                            "minItems": 1,
+                            "uniqueItems": true,
+                            "items": { "$ref": "#/$defs/stableKey" }
+                        },
+                        { "type": "null" }
+                    ]
+                },
+                "node_ref": { "$ref": "#/$defs/stableKey" }
+            }
+        },
+        "equivalenceCase": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["fact_rule_refs", "side_predicate", "axis_erased_predicate"],
+            "properties": {
+                "fact_rule_refs": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": { "$ref": "#/$defs/stableKey" }
+                },
+                "side_predicate": {
+                    "$ref": "design-resource-symbolic-source-ir-v1.schema.json#/$defs/predicate"
+                },
+                "axis_erased_predicate": {
+                    "$ref": "design-resource-symbolic-source-ir-v1.schema.json#/$defs/predicate"
+                }
+            }
+        },
+        "derivedResult": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "source_ir_resource_ref",
+                "static_dependency_nodes",
+                "static_rule_roots",
+                "equivalence_cases",
+                "complete_domain_cardinality",
+                "exhaustive_evaluation_sha256"
+            ],
+            "properties": {
+                "source_ir_resource_ref": {
+                    "oneOf": [{ "$ref": "#/$defs/stableKey" }, { "type": "null" }]
+                },
+                "static_dependency_nodes": {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/dependencyNode" }
+                },
+                "static_rule_roots": {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/dependencyRoot" }
+                },
+                "equivalence_cases": {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/equivalenceCase" }
+                },
+                "complete_domain_cardinality": {
+                    "oneOf": [
+                        { "type": "string", "pattern": "^(?:0|[1-9][0-9]*)$" },
+                        { "type": "null" }
+                    ]
+                },
+                "exhaustive_evaluation_sha256": {
+                    "oneOf": [{ "$ref": "#/$defs/sha256" }, { "type": "null" }]
+                }
+            }
+        },
+        "failureWitness": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "kind",
+                "side",
+                "certificate_scope_sha256",
+                "axis_ref",
+                "fact_rule_ref",
+                "resource_ref",
+                "path",
+                "locator",
+                "node_ref",
+                "byte_offset",
+                "assignment",
+                "detail"
+            ],
+            "properties": {
+                "kind": {
+                    "enum": [
+                        "omitted_axis_dependency",
+                        "unsupported_dependency",
+                        "source_rule_denotation_mismatch",
+                        "complete_domain_counterexample"
+                    ]
+                },
+                "side": { "enum": ["source", "production"] },
+                "certificate_scope_sha256": { "$ref": "#/$defs/sha256" },
+                "axis_ref": {
+                    "oneOf": [{ "$ref": "#/$defs/stableKey" }, { "type": "null" }]
+                },
+                "fact_rule_ref": {
+                    "oneOf": [{ "$ref": "#/$defs/stableKey" }, { "type": "null" }]
+                },
+                "resource_ref": {
+                    "oneOf": [{ "$ref": "#/$defs/stableKey" }, { "type": "null" }]
+                },
+                "path": {
+                    "oneOf": [{ "$ref": "#/$defs/nonemptyString" }, { "type": "null" }]
+                },
+                "locator": {
+                    "oneOf": [{ "$ref": "#/$defs/nonemptyString" }, { "type": "null" }]
+                },
+                "node_ref": {
+                    "oneOf": [{ "$ref": "#/$defs/stableKey" }, { "type": "null" }]
+                },
+                "byte_offset": {
+                    "oneOf": [{ "type": "integer", "minimum": 0 }, { "type": "null" }]
+                },
+                "assignment": {
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "propertyNames": { "$ref": "#/$defs/stableKey" },
+                            "additionalProperties": { "$ref": "#/$defs/scalar" }
+                        },
+                        { "type": "null" }
+                    ]
+                },
+                "detail": { "$ref": "#/$defs/nonemptyString" }
+            }
+        }
+    }
+}

package/dist/schemas/design-resource-symbolic-source-ir-v1.schema.json

@@ -0,0 +1,130 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://github.com/Seven128/project-tiny-context-harness/schemas/design-resource-symbolic-source-ir-v1.schema.json",
+    "title": "Project Tiny Context Symbolic Source IR v1",
+    "type": "object",
+    "additionalProperties": false,
+    "required": ["schema_version", "target_ref", "certificate_scopes"],
+    "properties": {
+        "schema_version": {
+            "const": "design-resource-symbolic-source-ir-v1"
+        },
+        "target_ref": {
+            "$ref": "#/$defs/stableKey"
+        },
+        "certificate_scopes": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                    "certificate_scope_sha256",
+                    "rule_scope_sha256",
+                    "regions"
+                ],
+                "properties": {
+                    "certificate_scope_sha256": { "$ref": "#/$defs/sha256" },
+                    "rule_scope_sha256": { "$ref": "#/$defs/sha256" },
+                    "regions": {
+                        "type": "array",
+                        "minItems": 1,
+                        "items": {
+                            "type": "object",
+                            "additionalProperties": false,
+                            "required": ["rule_region_sha256", "predicate"],
+                            "properties": {
+                                "rule_region_sha256": { "$ref": "#/$defs/sha256" },
+                                "predicate": { "$ref": "#/$defs/predicate" }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "$defs": {
+        "stableKey": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "^[a-z0-9][a-z0-9._-]*$"
+        },
+        "sha256": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+        },
+        "scalar": {
+            "oneOf": [{ "type": "string" }, { "type": "number" }]
+        },
+        "predicate": {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["op", "axis_ref", "value"],
+                    "properties": {
+                        "op": { "const": "eq" },
+                        "axis_ref": { "$ref": "#/$defs/stableKey" },
+                        "value": { "$ref": "#/$defs/scalar" }
+                    }
+                },
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["op", "axis_ref", "values"],
+                    "properties": {
+                        "op": { "const": "in" },
+                        "axis_ref": { "$ref": "#/$defs/stableKey" },
+                        "values": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": { "$ref": "#/$defs/scalar" }
+                        }
+                    }
+                },
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": [
+                        "op",
+                        "axis_ref",
+                        "minimum",
+                        "maximum",
+                        "minimum_inclusive",
+                        "maximum_inclusive"
+                    ],
+                    "properties": {
+                        "op": { "const": "range" },
+                        "axis_ref": { "$ref": "#/$defs/stableKey" },
+                        "minimum": { "type": "number" },
+                        "maximum": { "type": "number" },
+                        "minimum_inclusive": { "type": "boolean" },
+                        "maximum_inclusive": { "type": "boolean" }
+                    }
+                },
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["op", "predicates"],
+                    "properties": {
+                        "op": { "enum": ["all", "any"] },
+                        "predicates": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": { "$ref": "#/$defs/predicate" }
+                        }
+                    }
+                },
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["op", "predicate"],
+                    "properties": {
+                        "op": { "const": "not" },
+                        "predicate": { "$ref": "#/$defs/predicate" }
+                    }
+                }
+            ]
+        }
+    }
+}