@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/observability/observability-services.test.js

@@ -0,0 +1,219 @@
+import { afterEach, test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { decisionLedger as decisionLedgerTable, redactionManifest as redactionManifestTable, } from "../../../src/observability/db/schema/index.js";
+import { DecisionLedger } from "../../../src/observability/services/decision-ledger.js";
+import { GovernanceAudit } from "../../../src/observability/services/governance-audit.js";
+import { ExecutionTelemetry } from "../../../src/observability/services/execution-telemetry.js";
+const cleanupPaths = [];
+afterEach(() => {
+    while (cleanupPaths.length > 0) {
+        const target = cleanupPaths.pop();
+        if (target && fs.existsSync(target)) {
+            fs.rmSync(target, { force: true });
+        }
+    }
+});
+function createTempDb() {
+    const dbPath = path.join(os.tmpdir(), `observability-${Date.now()}-${Math.random().toString(16).slice(2)}.db`);
+    cleanupPaths.push(dbPath);
+    const database = createObservabilityDatabase(dbPath);
+    database.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS decision_ledger (
+      id TEXT PRIMARY KEY,
+      tick_id TEXT NOT NULL,
+      trace_id TEXT NOT NULL,
+      intent_id TEXT,
+      platform_id TEXT,
+      verdict TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      reasons TEXT NOT NULL,
+      reason_codes TEXT NOT NULL,
+      decision_basis TEXT NOT NULL,
+      evidence_refs TEXT NOT NULL,
+      model_eval_ref TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS decision_tick_idx ON decision_ledger(tick_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS decision_trace_idx ON decision_ledger(trace_id);
+
+    CREATE TABLE IF NOT EXISTS execution_attempts (
+      id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      decision_id TEXT NOT NULL,
+      intent_id TEXT NOT NULL,
+      platform_id TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      channel TEXT NOT NULL,
+      status TEXT NOT NULL,
+      commit_state TEXT,
+      failure_class TEXT,
+      retry_policy TEXT,
+      idempotency_key TEXT,
+      started_at TEXT,
+      finished_at TEXT
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS attempt_trace_idx ON execution_attempts(trace_id);
+    CREATE INDEX IF NOT EXISTS attempt_decision_idx ON execution_attempts(decision_id);
+    CREATE INDEX IF NOT EXISTS attempt_platform_idx ON execution_attempts(platform_id);
+
+    CREATE TABLE IF NOT EXISTS governance_audit (
+      id TEXT PRIMARY KEY,
+      event_type TEXT NOT NULL,
+      proposal_id TEXT,
+      target_asset_id TEXT,
+      asset_path TEXT,
+      status_from TEXT,
+      status_to TEXT NOT NULL,
+      before_hash TEXT,
+      after_hash TEXT,
+      supporting_sources TEXT,
+      reason TEXT,
+      verification_deadline TEXT,
+      attempts_remaining INTEGER,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS audit_proposal_idx ON governance_audit(proposal_id);
+    CREATE INDEX IF NOT EXISTS audit_asset_idx ON governance_audit(target_asset_id);
+    CREATE INDEX IF NOT EXISTS audit_event_idx ON governance_audit(event_type);
+
+    CREATE TABLE IF NOT EXISTS redaction_manifest (
+      id TEXT PRIMARY KEY,
+      event_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      field_name TEXT NOT NULL,
+      action TEXT NOT NULL,
+      original_value_hash TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS redact_event_idx ON redaction_manifest(event_id);
+  `);
+    return database;
+}
+test("DecisionLedger records decisions and append-style lifecycle events with redaction manifests", async () => {
+    const db = createTempDb();
+    const ledger = new DecisionLedger(db);
+    const decision = {
+        id: "decision-1",
+        tickId: "tick-1",
+        traceId: "trace-1",
+        intentId: "intent-1",
+        platformId: "instreet",
+        verdict: "allow",
+        mode: "active",
+        reasons: ["policy_ok"],
+        reasonCodes: ["policy_ok"],
+        decisionBasis: "rule_only",
+        evidenceRefs: ["asset:1"],
+        createdAt: new Date().toISOString(),
+    };
+    await ledger.recordDecision(decision);
+    await ledger.recordQuietLifecycle({
+        id: "quiet-1",
+        tickId: "tick-1",
+        eventType: "quiet.entered",
+        reason: "window_match",
+        reflectionCandidates: ["memory:today"],
+        createdAt: new Date().toISOString(),
+    });
+    await ledger.recordOutreachDecision({
+        id: "outreach-1",
+        tickId: "tick-2",
+        eventType: "outreach.deferred",
+        platformId: "instreet",
+        targetUserId: "user-1",
+        valueScore: 0.62,
+        suppressionReason: "low_urgency",
+        messagePreview: "hi there",
+        createdAt: new Date().toISOString(),
+    });
+    const decisionRows = await db.db.select().from(decisionLedgerTable);
+    assert.equal(decisionRows.length, 3);
+    const queriedByTick = await ledger.queryByTickId("tick-1");
+    assert.equal(queriedByTick.length, 2);
+    const outreachDecision = await ledger.queryByTraceId("outreach-outreach.deferred-outreach-1");
+    assert.ok(outreachDecision);
+    assert.equal(outreachDecision.verdict, "defer");
+    const manifests = await db.db.select().from(redactionManifestTable);
+    assert.ok(manifests.length >= 1);
+    assert.ok(manifests.some((row) => row.fieldName === "*" && row.action === "none"));
+    db.close();
+});
+test("GovernanceAudit records anchor and credential events without collapsing platform identity", async () => {
+    const db = createTempDb();
+    const audit = new GovernanceAudit(db);
+    const anchorEvent = {
+        id: "anchor-1",
+        proposalId: "proposal-1",
+        targetAssetId: "SOUL.md",
+        assetPath: "workspace/SOUL.md",
+        status: "applied",
+        beforeHash: "before",
+        afterHash: "after",
+        supportingSources: ["memory:today"],
+        reason: "approved update",
+        appliedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+    };
+    await audit.recordAnchorChangeAudit(anchorEvent);
+    await audit.recordCredentialLifecycle({
+        id: "cred-1",
+        platformId: "instreet",
+        credentialId: "cred-instreet-1",
+        statusFrom: "pending_verification",
+        statusTo: "active",
+        verificationDeadline: new Date().toISOString(),
+        attemptsRemaining: 4,
+        explanationCapsule: "verification successful",
+        createdAt: new Date().toISOString(),
+    });
+    const anchorRows = await audit.queryByProposalId("proposal-1");
+    assert.equal(anchorRows.length, 1);
+    assert.equal(anchorRows[0]?.status, "applied");
+    const credentialRows = await audit.queryCredentialByPlatform("instreet");
+    assert.equal(credentialRows.length, 1);
+    assert.equal(credentialRows[0]?.platformId, "instreet");
+    assert.equal(credentialRows[0]?.credentialId, "cred-instreet-1");
+    const redactions = await db.db.select().from(redactionManifestTable);
+    assert.ok(redactions.length >= 1);
+    db.close();
+});
+test("ExecutionTelemetry records attempts and updates commit state for replay analysis", async () => {
+    const db = createTempDb();
+    const telemetry = new ExecutionTelemetry(db);
+    const attempt = {
+        id: "attempt-1",
+        traceId: "trace-telemetry-1",
+        decisionId: "decision-telemetry-1",
+        intentId: "intent-telemetry-1",
+        platformId: "evomap",
+        capability: "agent.heartbeat",
+        channel: "api_rest",
+        status: "started",
+        commitState: "planned",
+        retryPolicy: "none",
+        idempotencyKey: "heartbeat-1",
+        metadata: { node_secret: "should-mask" },
+        startedAt: new Date().toISOString(),
+    };
+    await telemetry.recordExecutionAttempt(attempt);
+    await telemetry.updateCommitState("trace-telemetry-1", "externally_acknowledged");
+    await telemetry.completeAttempt("trace-telemetry-1", "succeeded", "committed");
+    const queried = await telemetry.queryByTraceId("trace-telemetry-1");
+    assert.ok(queried);
+    assert.equal(queried.commitState, "committed");
+    assert.equal(queried.status, "succeeded");
+    const byDecision = await telemetry.queryByDecisionId("decision-telemetry-1");
+    assert.equal(byDecision.length, 1);
+    const byPlatform = await telemetry.queryByPlatform("evomap");
+    assert.equal(byPlatform.length, 1);
+    const byCommitState = await telemetry.queryByCommitState("committed");
+    assert.equal(byCommitState.length, 1);
+    const manifests = await db.db.select().from(redactionManifestTable);
+    assert.ok(manifests.some((row) => row.fieldName === "metadata.node_secret" && row.action === "mask"));
+    assert.ok(!manifests.some((row) => row.fieldName === "_none" && row.action === "mask"));
+    db.close();
+});

package/dist/tests/integration/observability/projections.test.d.ts

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

package/dist/tests/integration/observability/projections.test.js

@@ -0,0 +1,36 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { projectReflectionAudit } from "../../../src/observability/projections/reflection-audit.js";
+import { projectOutreachQualityAudit } from "../../../src/observability/projections/outreach-quality-audit.js";
+test("reflection projection keeps extension fields serializable", () => {
+    const projection = projectReflectionAudit({
+        id: "reflection-1",
+        claimCount: 5,
+        unsupportedClaimCount: 1,
+        sourceCoverageRatio: 0.8,
+        reflectionDebt: 2,
+        starved: false,
+        modelEvalRef: "model-eval-1",
+    });
+    assert.equal(projection.eventId, "reflection-1");
+    assert.equal(projection.unsupportedClaimCount, 1);
+    assert.equal(projection.sourceCoverageRatio, 0.8);
+    assert.equal(projection.claimCount, 5);
+    assert.equal(projection.modelEvalRef, "model-eval-1");
+    assert.doesNotThrow(() => JSON.stringify(projection));
+});
+test("outreach quality projection keeps value and suppression fields", () => {
+    const projection = projectOutreachQualityAudit({
+        id: "outreach-1",
+        valueScore: 0.73,
+        noveltyScore: 0.51,
+        requiredUserAction: true,
+        suppressionReason: "cooldown",
+    });
+    assert.equal(projection.eventId, "outreach-1");
+    assert.equal(projection.valueScore, 0.73);
+    assert.equal(projection.noveltyScore, 0.51);
+    assert.equal(projection.requiredUserAction, true);
+    assert.equal(projection.suppressionReason, "cooldown");
+    assert.doesNotThrow(() => JSON.stringify(projection));
+});

package/dist/tests/integration/observability/t5-1-1-dream-trace-audit.test.d.ts

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

package/dist/tests/integration/observability/t5-1-1-dream-trace-audit.test.js

@@ -0,0 +1,115 @@
+/**
+ * T5.1.1 — DreamTrace audit envelope emitted by LivedExperienceAuditRecorder.
+ *
+ * Acceptance:
+ * A. recordDreamTrace writes a dream.trace family envelope into the audit store.
+ * B. Envelope contains correct traceId, runId, durationMs, inputCounts, fallbackReason.
+ * C. No fallbackReason → lifecycleStatus inferred as "completed" by read model.
+ * D. With fallbackReason → lifecycleStatus inferred as "partial" by read model.
+ * E. Empty store returns honest empty (totalRuns: 0, runs: []) via loadDreamRecent.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
+import { createLivedExperienceAuditRecorder } from "../../../src/observability/services/lived-experience-audit.js";
+import { createCliReadModels } from "../../../src/cli/read-models/index.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+test("T5.1.1-A: recordDreamTrace writes dream.trace envelope into audit store", async () => {
+    const store = new AppendOnlyAuditStore();
+    const recorder = createLivedExperienceAuditRecorder(store);
+    const trace = {
+        traceId: "dream:trace-001",
+        runId: "run-001",
+        startedAt: "2026-05-16T08:00:00Z",
+        finishedAt: "2026-05-16T08:01:30Z",
+        durationMs: 90000,
+        inputCounts: { evidence: 3, chronicle: 2, memoryEntries: 5 },
+    };
+    const result = recorder.recordDreamTrace(trace);
+    assert.ok(result.eventId, "eventId must be present");
+    const events = store.list();
+    assert.equal(events.length, 1);
+    assert.equal(events[0].family, "dream.trace");
+    assert.equal(events[0].plane, "telemetry");
+    assert.equal(events[0].traceId, "dream:trace-001");
+});
+test("T5.1.1-B: loadDreamRecent returns correct fields for completed run", async () => {
+    const store = new AppendOnlyAuditStore();
+    const recorder = createLivedExperienceAuditRecorder(store);
+    recorder.recordDreamTrace({
+        traceId: "dream:trace-002",
+        runId: "run-002",
+        startedAt: "2026-05-16T08:00:00Z",
+        finishedAt: "2026-05-16T08:01:00Z",
+        durationMs: 60000,
+        inputCounts: { evidence: 2, chronicle: 1, memoryEntries: 3 },
+    });
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb, livedExperienceAuditStore: store });
+    const recent = await readModels.loadDreamRecent(5);
+    assert.equal(recent.totalRuns, 1);
+    assert.equal(recent.runs.length, 1);
+    const run = recent.runs[0];
+    assert.equal(run.traceId, "dream:trace-002");
+    assert.equal(run.runId, "run-002");
+    assert.equal(run.durationMs, 60000);
+    assert.deepEqual(run.inputCounts, { evidence: 2, chronicle: 1, memoryEntries: 3 });
+    assert.equal(run.lifecycleStatus, "completed");
+    assert.equal(run.fallbackReason, undefined);
+    assert.equal(run.insightsCount, 0);
+    assert.ok(typeof run.createdAt === "string");
+});
+test("T5.1.1-C: loadDreamRecent infers partial status when fallbackReason present", async () => {
+    const store = new AppendOnlyAuditStore();
+    const recorder = createLivedExperienceAuditRecorder(store);
+    recorder.recordDreamTrace({
+        traceId: "dream:trace-003",
+        runId: "run-003",
+        startedAt: "2026-05-16T08:00:00Z",
+        finishedAt: "2026-05-16T08:00:10Z",
+        durationMs: 10000,
+        inputCounts: { evidence: 1, chronicle: 0, memoryEntries: 1 },
+        fallbackReason: "validation_failed_schema",
+    });
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb, livedExperienceAuditStore: store });
+    const recent = await readModels.loadDreamRecent(5);
+    assert.equal(recent.runs[0].lifecycleStatus, "partial");
+    assert.equal(recent.runs[0].fallbackReason, "validation_failed_schema");
+});
+test("T5.1.1-D: loadDreamRecent respects limit and sorts descending by createdAt", async () => {
+    const store = new AppendOnlyAuditStore();
+    const recorder = createLivedExperienceAuditRecorder(store);
+    for (let i = 0; i < 5; i++) {
+        recorder.recordDreamTrace({
+            traceId: `dream:trace-${i}`,
+            runId: `run-${i}`,
+            startedAt: "2026-05-16T08:00:00Z",
+            finishedAt: `2026-05-16T0${i}:00:00Z`,
+            durationMs: 1000,
+            inputCounts: { evidence: 1, chronicle: 0, memoryEntries: 0 },
+        });
+    }
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb, livedExperienceAuditStore: store });
+    const recent = await readModels.loadDreamRecent(2);
+    assert.equal(recent.totalRuns, 5);
+    assert.equal(recent.runs.length, 2);
+    // Descending order: run-4 (04:00) should come first
+    assert.equal(recent.runs[0].runId, "run-4");
+    assert.equal(recent.runs[1].runId, "run-3");
+});
+test("T5.1.1-E: loadDreamRecent returns honest empty when store has no dream traces", async () => {
+    const store = new AppendOnlyAuditStore();
+    // No dream traces inserted
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb, livedExperienceAuditStore: store });
+    const recent = await readModels.loadDreamRecent(5);
+    assert.equal(recent.totalRuns, 0);
+    assert.deepEqual(recent.runs, []);
+});

package/dist/tests/integration/plugin/plugin-registration.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * T-ROS.C.2 — Plugin registration & WorkspaceOpsBridge v7 extension.
+ *
+ * Verifies:
+ *   1. Plugin loads without touching DB (host-safe register() mode)
+ *   2. second_nature_ops tool is exposed after register()
+ *   3. All v7 commands are routed through the workspace bridge path
+ *      (isWorkspaceBridgeCommand returns true for each v7 command)
+ *   4. parseCommandInput() produces well-formed ParsedCommand for each v7 command
+ *
+ * Does NOT open a real workspace DB — uses the carrier (non-bridge) path only,
+ * so the test can run in CI without a workspace root.
+ *
+ * Evidence: tests/integration/plugin/plugin-registration.test.ts
+ */
+export {};

package/dist/tests/integration/plugin/plugin-registration.test.js

@@ -0,0 +1,151 @@
+/**
+ * T-ROS.C.2 — Plugin registration & WorkspaceOpsBridge v7 extension.
+ *
+ * Verifies:
+ *   1. Plugin loads without touching DB (host-safe register() mode)
+ *   2. second_nature_ops tool is exposed after register()
+ *   3. All v7 commands are routed through the workspace bridge path
+ *      (isWorkspaceBridgeCommand returns true for each v7 command)
+ *   4. parseCommandInput() produces well-formed ParsedCommand for each v7 command
+ *
+ * Does NOT open a real workspace DB — uses the carrier (non-bridge) path only,
+ * so the test can run in CI without a workspace root.
+ *
+ * Evidence: tests/integration/plugin/plugin-registration.test.ts
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadPlugin() {
+    const pluginUrl = pathToFileURL(path.join(process.cwd(), "plugin", "index.js")).href;
+    const mod = await import(pluginUrl);
+    return mod.default;
+}
+// ─── T-ROS.C.2 / AC-1: host-safe register() never throws ───────────────────
+test("T-ROS.C.2 AC-1 — plugin register() does not throw without workspace root", async () => {
+    delete process.env.SECOND_NATURE_WORKSPACE_ROOT;
+    const plugin = await loadPlugin();
+    const services = [];
+    const commands = [];
+    const tools = [];
+    // Should not throw regardless of env
+    assert.doesNotThrow(() => {
+        plugin.register({
+            registerService(s) { services.push(s.id); },
+            registerCommand(c) { commands.push(c.name); },
+            registerTool(t) { tools.push(t); },
+        });
+    });
+    // Must expose at least one tool
+    assert.ok(tools.length >= 1, "Expected at least one tool registered");
+});
+// ─── T-ROS.C.2 / AC-2: second_nature_ops tool is visible ───────────────────
+test("T-ROS.C.2 AC-2 — second_nature_ops tool is registered and executable", async () => {
+    delete process.env.SECOND_NATURE_WORKSPACE_ROOT;
+    const plugin = await loadPlugin();
+    let tool;
+    plugin.register({
+        registerService() { },
+        registerCommand() { },
+        registerTool(t) {
+            tool = t;
+        },
+    });
+    assert.ok(tool, "second_nature_ops tool must be registered");
+    assert.equal(typeof tool.execute, "function", "tool.execute must be a function");
+    // Execute a command without workspace root — should return ok:false gracefully (no crash)
+    const result = await tool.execute("1", { command: "self_health" });
+    assert.ok(Array.isArray(result.content), "tool must return {content: [...]}");
+    assert.equal(result.content[0]?.type, "text", "content[0].type must be 'text'");
+    const payload = JSON.parse(result.content[0].text);
+    // Without workspace root it will fail (no bridge), but must not throw
+    assert.equal(typeof payload.ok, "boolean", "response payload must have ok field");
+});
+// ─── T-ROS.C.2 / AC-3: v7 commands routed through workspace bridge ──────────
+const V7_COMMANDS = [
+    "self_health",
+    "tool_affordance",
+    "heartbeat_digest",
+    "snapshot:capture",
+    "narrative:diff",
+    "timeline",
+    "restore",
+    "runtime_secret_bootstrap",
+    // T-V7C.C.5: host ops surface parity
+    "connector:run",
+    "guidance_payload",
+];
+for (const cmd of V7_COMMANDS) {
+    test(`T-ROS.C.2 AC-3 — ${cmd} is in WORKSPACE_BRIDGE_COMMANDS`, async () => {
+        delete process.env.SECOND_NATURE_WORKSPACE_ROOT;
+        const plugin = await loadPlugin();
+        let tool;
+        plugin.register({
+            registerService() { },
+            registerCommand() { },
+            registerTool(t) { tool = t; },
+        });
+        assert.ok(tool);
+        // Without a real workspace root the bridge fails gracefully.
+        // The important thing is that the dispatch reaches the bridge layer (ok: false with
+        // a bridge/workspace error, NOT "unknown_command").
+        const result = await tool.execute("1", { command: cmd });
+        const payload = JSON.parse(result.content[0].text);
+        // "unknown_command" would mean the command was NOT in WORKSPACE_BRIDGE_COMMANDS
+        // (it would have been processed by carrier and failed there). Any other error code
+        // means the bridge layer was reached.
+        assert.notEqual(payload.error?.code, "unknown_command", `${cmd} must not return unknown_command — it must be in WORKSPACE_BRIDGE_COMMANDS`);
+    });
+}
+// ─── T-ROS.C.2 / AC-4: parseCommandInput produces valid shapes ──────────────
+test("T-ROS.C.2 AC-4 — self_health input is undefined (no args needed)", async () => {
+    delete process.env.SECOND_NATURE_WORKSPACE_ROOT;
+    const plugin = await loadPlugin();
+    let tool;
+    plugin.register({
+        registerService() { },
+        registerCommand() { },
+        registerTool(t) { tool = t; },
+    });
+    assert.ok(tool);
+    // self_health requires no arguments; passing stray args should not crash
+    const result = await tool.execute("1", { command: "self_health", args: {} });
+    const payload = JSON.parse(result.content[0].text);
+    assert.equal(typeof payload.ok, "boolean");
+});
+test("T-ROS.C.2 AC-4 — heartbeat_digest passes date arg", async () => {
+    delete process.env.SECOND_NATURE_WORKSPACE_ROOT;
+    const plugin = await loadPlugin();
+    let tool;
+    plugin.register({
+        registerService() { },
+        registerCommand() { },
+        registerTool(t) { tool = t; },
+    });
+    assert.ok(tool);
+    const result = await tool.execute("1", {
+        command: "heartbeat_digest",
+        args: { date: "2025-01-01" },
+    });
+    const payload = JSON.parse(result.content[0].text);
+    // Must reach bridge, not blow up with unknown_command
+    assert.notEqual(payload.error?.code, "unknown_command");
+});
+test("T-ROS.C.2 AC-4 — restore passes restoreTarget/fromVersion/toVersion", async () => {
+    delete process.env.SECOND_NATURE_WORKSPACE_ROOT;
+    const plugin = await loadPlugin();
+    let tool;
+    plugin.register({
+        registerService() { },
+        registerCommand() { },
+        registerTool(t) { tool = t; },
+    });
+    assert.ok(tool);
+    const result = await tool.execute("1", {
+        command: "restore",
+        args: { restoreTarget: "state", fromVersion: "v1", toVersion: "v2" },
+    });
+    const payload = JSON.parse(result.content[0].text);
+    assert.notEqual(payload.error?.code, "unknown_command");
+});

package/dist/tests/integration/runtime-ops/commands.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * T-ROS.C.1 集成测试 — RuntimeSurfaceRouter v7 命令集
+ *
+ * 验收标准（05A_TASKS.md T-ROS.C.1）:
+ *  - connector_test --wet: dryRun=false + triggerSource:"manual" + affectsHeartbeatCadence=false
+ *  - self_health: 返回 RuntimeOpsEnvelope, data 含 overall/dimensions/degraded_dimensions
+ *  - heartbeat_digest: 返回 RuntimeOpsEnvelope + digest; 无 auditStore 时降级
+ *  - narrative:diff: 返回 RuntimeOpsEnvelope + diff; 无 deps 时降级
+ *  - timeline: 返回 RuntimeOpsEnvelope + page; range 超 90 天时 ok=false + NARRATIVE_RANGE_EXCEEDED
+ *  - restore: 触发 RestoreSnapshotStore + RestoreAudit, ok=true, data.auditWritten=true; 无 auditStore 时降级
+ *  - runtime_secret_bootstrap: 返回 RuntimeOpsEnvelope; plaintextKeyExposed=false
+ *  - tool_affordance: port 未连线时 ok=false + TOOL_AFFORDANCE_PORT_UNWIRED
+ *
+ * Evidence: reports/int-s5-observability-v7.md (T-ROS.C.1 is part of Wave 67)
+ */
+export {};