chainlesschain 0.166.141 → 0.166.143

package/src/lib/plugin-runtime/cli-goal-events.js

@@ -0,0 +1,175 @@
+/** Explicit, bounded polling of standalone goal status. No durable event log. */
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { setTimeout as delay } from "node:timers/promises";
+import { cliGoalExtensionHost } from "./cli-goal-capabilities.js";
+import { resolveConfigDataRoot } from "../paths.js";
+import { managedSettingsPath } from "../settings-loader.cjs";
+import { createCliGoalSnapshotReader } from "../cli-goal-source.js";
+import {
+  collectGoalExtensions,
+  projectGoalExtensionEvent,
+} from "./goal-extensions.js";
+
+const TYPE = "goal.status.changed";
+export const CLI_GOAL_EVENT_SCHEMA = "chainlesschain.goal-extension-stream/v1";
+export const _deps = { projectGoalExtensionEvent };
+const fail = (code) => {
+  throw new Error(code);
+};
+
+/** Capture selection synchronously; retained iterators never change workspace. */
+export function watchCliGoalExtensionEvents(id, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const env = Object.freeze({ ...(options.env || process.env) });
+  const root = path.resolve(
+    options.root ||
+      path.join(resolveConfigDataRoot({ cwd, env }).path, "goals"),
+  );
+  const managedSettingsFile = managedSettingsPath({
+    env,
+    managedSettingsFile: options.managedSettingsFile,
+  });
+  const name = options.plugin,
+    scope = options.scope;
+  const expectedStore = options.expectedStore;
+  const intervalMs = options.intervalMs ?? 1000;
+  const durationMs = options.durationMs ?? 60000;
+  const signal = options.signal;
+  if (options.connection !== undefined) fail("CLI_GOAL_EVENTS_STANDALONE_ONLY");
+  if (typeof name !== "string" || !name || name.length > 256)
+    fail("CLI_GOAL_INVALID_PLUGIN_NAME");
+  if (scope !== undefined && !["user", "project", "local"].includes(scope))
+    fail("CLI_GOAL_INVALID_PLUGIN_SCOPE");
+  if (
+    !Number.isSafeInteger(intervalMs) ||
+    intervalMs < 250 ||
+    intervalMs > 60000 ||
+    !Number.isSafeInteger(durationMs) ||
+    durationMs < 1000 ||
+    durationMs > 900000
+  )
+    fail("CLI_GOAL_INVALID_WATCH_LIMIT");
+  if (signal !== undefined && !(signal instanceof AbortSignal))
+    fail("CLI_GOAL_INVALID_WATCH_SIGNAL");
+  const host = cliGoalExtensionHost([`event:${TYPE}`]);
+  const admission = Object.freeze({ cwd, env, managedSettingsFile, host });
+
+  return (async function* () {
+    if (signal?.aborted) return;
+    const source = createCliGoalSnapshotReader(root);
+    if (expectedStore !== undefined && expectedStore !== source.storeId)
+      fail("CLI_GOAL_STORE_MISMATCH");
+    const matches = collectGoalExtensions(admission).extensions.filter(
+      (entry) =>
+        entry.name === name &&
+        (!scope || entry.scope === scope) &&
+        entry.declaration.events.includes(TYPE),
+    );
+    if (matches.length !== 1) fail("CLI_GOAL_EVENT_PLUGIN_UNAVAILABLE");
+    const plugin = matches[0];
+    const ref = Object.freeze({
+      name: plugin.name,
+      scope: plugin.scope,
+      version: plugin.version,
+    });
+    const declaration = JSON.stringify(plugin.declaration);
+    function revalidatePlugin() {
+      const current = collectGoalExtensions(admission).extensions.find(
+        (entry) =>
+          entry.name === ref.name &&
+          entry.scope === ref.scope &&
+          entry.version === ref.version,
+      );
+      if (!current || JSON.stringify(current.declaration) !== declaration)
+        fail("CLI_GOAL_EVENT_ADMISSION_CHANGED");
+    }
+    const reference = (goal) =>
+      Object.freeze({
+        id: goal.id,
+        storeId: goal.storeId,
+        revision: goal.revision,
+        controlGeneration: goal.controlGeneration,
+      });
+    let snapshot = source.read(id);
+    source.revalidate(snapshot);
+    revalidatePlugin();
+    const deadline = performance.now() + durationMs;
+    yield Object.freeze({
+      schema: CLI_GOAL_EVENT_SCHEMA,
+      kind: "ready",
+      plugin: ref,
+      goalRef: reference(snapshot.goal),
+      observedAt: new Date().toISOString(),
+      delivery: "polling",
+      replay: false,
+    });
+    while (!signal?.aborted && performance.now() < deadline) {
+      try {
+        await delay(
+          Math.min(intervalMs, Math.max(1, deadline - performance.now())),
+          undefined,
+          { signal },
+        );
+      } catch (error) {
+        if (signal?.aborted && error.name === "AbortError") return;
+        throw error;
+      }
+      if (signal?.aborted || performance.now() >= deadline) return;
+      revalidatePlugin();
+      const current = source.read(id);
+      if (
+        current.goal.revision < snapshot.goal.revision ||
+        current.goal.controlGeneration < snapshot.goal.controlGeneration
+      )
+        fail("CLI_GOAL_EVENT_SOURCE_REGRESSED");
+      if (current.digest === snapshot.digest) continue;
+      const previousStatus = snapshot.goal.status;
+      if (current.goal.status === previousStatus) {
+        snapshot = current;
+        continue;
+      }
+      const goalRef = reference(current.goal);
+      // occurredAt is observation time: polling cannot establish mutation time.
+      const observedAt = new Date().toISOString();
+      const event = await _deps.projectGoalExtensionEvent(
+        ref,
+        { type: TYPE, goalRef },
+        {
+          ...admission,
+          authorize(context) {
+            if (
+              context.operation !== "read-event" ||
+              context.type !== TYPE ||
+              JSON.stringify(context.goalRef) !== JSON.stringify(goalRef)
+            )
+              return false;
+            source.revalidate(current);
+            revalidatePlugin();
+            return true;
+          },
+          readEvent() {
+            source.revalidate(current);
+            return {
+              summary: `status: ${previousStatus} -> ${current.goal.status}`,
+              occurredAt: observedAt,
+            };
+          },
+        },
+      );
+      source.revalidate(current);
+      revalidatePlugin();
+      if (signal?.aborted || performance.now() >= deadline) return;
+      snapshot = current;
+      yield Object.freeze({
+        schema: CLI_GOAL_EVENT_SCHEMA,
+        kind: "event",
+        plugin: ref,
+        observedAt,
+        delivery: "polling",
+        replay: false,
+        event,
+      });
+    }
+  })();
+}

package/src/lib/plugin-runtime/cli-goal-extension-host.js

@@ -1,7 +1,7 @@
 /** Explicit goal panels from standalone files or a short-lived desktop read lease. */
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { VERSION } from "../../constants.js";
+import { cliGoalExtensionHost } from "./cli-goal-capabilities.js";
 import { resolveConfigDataRoot } from "../paths.js";
 import { managedSettingsPath } from "../settings-loader.cjs";
 import { createCliGoalSnapshotReader } from "../cli-goal-source.js";
@@ -13,11 +13,9 @@ import {
 } from "./goal-extensions.js";
 
 export const CLI_GOAL_PANEL_SCHEMA = "chainlesschain.goal-extension-panels.v1";
-export const CLI_GOAL_EXTENSION_HOST = Object.freeze({
-  id: "cli",
-  version: VERSION,
-  capabilities: Object.freeze(["panel:goal.summary"]),
-});
+export const CLI_GOAL_EXTENSION_HOST = cliGoalExtensionHost([
+  "panel:goal.summary",
+]);
 export const _deps = { collectGoalExtensions, projectGoalExtensionPanel };
 
 function fail(code) {
@@ -95,13 +93,7 @@ export async function readCliGoalExtensionPanels(id, options = {}) {
     env,
     managedSettingsFile,
     host: connection?.evidence
-      ? Object.freeze({
-          ...CLI_GOAL_EXTENSION_HOST,
-          capabilities: Object.freeze([
-            "panel:goal.summary",
-            "panel:goal.evidence",
-          ]),
-        })
+      ? cliGoalExtensionHost(["panel:goal.summary", "panel:goal.evidence"])
       : CLI_GOAL_EXTENSION_HOST,
     async authorize(context) {
       if (
@@ -169,6 +161,22 @@ export async function readCliGoalExtensionPanels(id, options = {}) {
     const projected = [];
     try {
       for (const panel of plugin.declaration.panels) {
+        if (
+          !hostOptions.host.activeCapabilities.includes(`panel:${panel.slot}`)
+        ) {
+          if (
+            !dropped.some(
+              (entry) =>
+                entry.name === plugin.name && entry.scope === plugin.scope,
+            )
+          )
+            dropped.push({
+              name: plugin.name,
+              scope: plugin.scope,
+              reason: "unsupported_capabilities",
+            });
+          continue;
+        }
         projected.push({
           plugin: ref,
           ...(await _deps.projectGoalExtensionPanel(

package/src/lib/plugin-runtime/cli-project-goal-events.js

@@ -0,0 +1,212 @@
+/** A separately consented v4 lease observes bounded native evidence snapshots. */
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { setTimeout as delay } from "node:timers/promises";
+import { createHash } from "node:crypto";
+import { cliGoalExtensionHost } from "./cli-goal-capabilities.js";
+import { managedSettingsPath } from "../settings-loader.cjs";
+import { createProjectGoalConnection } from "../project-goal-connection.js";
+import {
+  collectGoalExtensions,
+  projectGoalExtensionEvent,
+} from "./goal-extensions.js";
+
+const TYPES = ["risk.review.completed", "action.receipt.updated"];
+const SCHEMA = "chainlesschain.goal-extension-stream/v1";
+export const _deps = { createProjectGoalConnection, projectGoalExtensionEvent };
+const fail = (code) => {
+  throw new Error(code);
+};
+const digest = (value) =>
+  createHash("sha256").update(JSON.stringify(value)).digest("hex");
+
+/** Capture options before any I/O. Never reinterpret another lease as events. */
+export function watchCliProjectGoalEvents(id, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const env = Object.freeze({ ...(options.env || process.env) });
+  const managedSettingsFile = managedSettingsPath({
+    env,
+    managedSettingsFile: options.managedSettingsFile,
+  });
+  const name = options.plugin,
+    scope = options.scope,
+    expectedStore = options.expectedStore;
+  const connectionFile = options.connection;
+  const intervalMs = options.intervalMs ?? 1000,
+    durationMs = options.durationMs ?? 60000;
+  const signal = options.signal;
+  if (typeof name !== "string" || !name || name.length > 256)
+    fail("CLI_GOAL_INVALID_PLUGIN_NAME");
+  if (scope !== undefined && !["user", "project", "local"].includes(scope))
+    fail("CLI_GOAL_INVALID_PLUGIN_SCOPE");
+  if (
+    !Number.isSafeInteger(intervalMs) ||
+    intervalMs < 250 ||
+    intervalMs > 60000 ||
+    !Number.isSafeInteger(durationMs) ||
+    durationMs < 1000 ||
+    durationMs > 900000
+  )
+    fail("CLI_GOAL_INVALID_WATCH_LIMIT");
+  if (signal !== undefined && !(signal instanceof AbortSignal))
+    fail("CLI_GOAL_INVALID_WATCH_SIGNAL");
+  const host = cliGoalExtensionHost(TYPES.map((type) => `event:${type}`));
+  const admission = Object.freeze({ cwd, env, managedSettingsFile, host });
+  return (async function* () {
+    if (signal?.aborted) return;
+    const source = _deps.createProjectGoalConnection(connectionFile);
+    if (!source.events || typeof source.readEvents !== "function")
+      fail("CLI_GOAL_EVENT_CONNECTION_REQUIRED");
+    const goalRef = source.goalRef;
+    if (
+      id !== goalRef.id ||
+      (expectedStore !== undefined && expectedStore !== goalRef.storeId)
+    )
+      fail("CLI_GOAL_STORE_MISMATCH");
+    const matches = collectGoalExtensions(admission).extensions.filter(
+      (entry) =>
+        entry.name === name &&
+        (!scope || entry.scope === scope) &&
+        entry.declaration.events.some((type) => TYPES.includes(type)),
+    );
+    if (matches.length !== 1) fail("CLI_GOAL_EVENT_PLUGIN_UNAVAILABLE");
+    const plugin = matches[0];
+    const ref = Object.freeze({
+      name: plugin.name,
+      scope: plugin.scope,
+      version: plugin.version,
+    });
+    const declaration = digest(plugin.declaration);
+    function revalidatePlugin() {
+      const current = collectGoalExtensions(admission).extensions.find(
+        (entry) =>
+          entry.name === ref.name &&
+          entry.scope === ref.scope &&
+          entry.version === ref.version,
+      );
+      if (!current || digest(current.declaration) !== declaration)
+        fail("CLI_GOAL_EVENT_ADMISSION_CHANGED");
+    }
+    const deadline = performance.now() + durationMs;
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    const timer = setTimeout(stop, durationMs);
+    timer.unref();
+    signal?.addEventListener("abort", stop, { once: true });
+    if (signal?.aborted) stop();
+    async function read() {
+      revalidatePlugin();
+      const value = await source.readEvents(id, { signal: controller.signal });
+      revalidatePlugin();
+      return value;
+    }
+    async function revalidate(snapshot) {
+      if (digest(await read()) !== digest(snapshot))
+        fail("CLI_GOAL_EVENT_SOURCE_CHANGED");
+    }
+    try {
+      let previous = await read();
+      await revalidate(previous);
+      if (controller.signal.aborted) return;
+      yield Object.freeze({
+        schema: SCHEMA,
+        kind: "ready",
+        source: "desktop-project",
+        plugin: ref,
+        goalRef,
+        observedAt: new Date().toISOString(),
+        delivery: "polling",
+        replay: false,
+      });
+      while (!controller.signal.aborted && performance.now() < deadline) {
+        await delay(
+          Math.min(intervalMs, Math.max(1, deadline - performance.now())),
+          undefined,
+          { signal: controller.signal },
+        );
+        if (controller.signal.aborted || performance.now() >= deadline) return;
+        const current = await read();
+        if (digest(current) === digest(previous)) continue;
+        const events = [];
+        if (
+          (previous.risk.reviewId && !current.risk.reviewId) ||
+          (previous.receipts.state === "recorded" &&
+            current.receipts.state !== "recorded")
+        )
+          fail("CLI_GOAL_EVENT_SOURCE_REGRESSED");
+        if (
+          current.risk.reviewId &&
+          digest(current.risk) !== digest(previous.risk) &&
+          plugin.declaration.events.includes(TYPES[0])
+        )
+          events.push({
+            type: TYPES[0],
+            summary: `Historical risk check ${current.risk.reviewId}: ${current.risk.state}; risk task count ${current.risk.riskTaskCount ?? "unknown"}. Current risk and goal completion require native verification.`,
+          });
+        for (const receipt of current.receipts.entries) {
+          const before = previous.receipts.entries.find(
+            (entry) => entry.id === receipt.id,
+          );
+          if (
+            before &&
+            before.status !== "unresolved" &&
+            digest(before) !== digest(receipt)
+          )
+            fail("CLI_GOAL_EVENT_SOURCE_REGRESSED");
+          if (
+            (!before || digest(receipt) !== digest(before)) &&
+            plugin.declaration.events.includes(TYPES[1])
+          )
+            events.push({
+              type: TYPES[1],
+              summary: `Historical action receipt ${receipt.id}: ${receipt.status} (${receipt.actionType}). This does not prove goal completion.`,
+            });
+        }
+        for (const candidate of events) {
+          const observedAt = new Date().toISOString();
+          const event = await _deps.projectGoalExtensionEvent(
+            ref,
+            { type: candidate.type, goalRef },
+            {
+              ...admission,
+              async authorize(context) {
+                if (
+                  context.operation !== "read-event" ||
+                  context.type !== candidate.type ||
+                  JSON.stringify(context.goalRef) !== JSON.stringify(goalRef)
+                )
+                  return false;
+                await revalidate(current);
+                return true;
+              },
+              async readEvent() {
+                await revalidate(current);
+                return { summary: candidate.summary, occurredAt: observedAt };
+              },
+            },
+          );
+          await revalidate(current);
+          if (controller.signal.aborted || performance.now() >= deadline)
+            return;
+          yield Object.freeze({
+            schema: SCHEMA,
+            kind: "event",
+            source: "desktop-project",
+            plugin: ref,
+            observedAt,
+            delivery: "polling",
+            replay: false,
+            event,
+          });
+        }
+        previous = current;
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) throw error;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", stop);
+      controller.abort();
+    }
+  })();
+}

package/src/lib/plugin-runtime/examples/goal-project-observer/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "goal-project-observer",
+  "version": "0.1.0",
+  "description": "Observe bounded native risk-check and action-receipt summaries through a separately authorized desktop event connection",
+  "permissions": {
+    "goalExtension": [
+      "event:risk.review.completed",
+      "event:action.receipt.updated"
+    ]
+  },
+  "goalExtension": {
+    "apiVersion": "1.0.0",
+    "hosts": {
+      "cli": ">=0.166.142"
+    },
+    "events": ["risk.review.completed", "action.receipt.updated"],
+    "panels": [],
+    "proposals": []
+  }
+}

package/src/lib/plugin-runtime/examples/goal-status-observer/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "goal-status-observer",
+  "version": "0.1.0",
+  "description": "Observe status changes of one explicitly selected standalone CLI goal",
+  "permissions": {
+    "goalExtension": ["event:goal.status.changed"]
+  },
+  "goalExtension": {
+    "apiVersion": "1.0.0",
+    "hosts": {
+      "cli": ">=0.166.142"
+    },
+    "events": ["goal.status.changed"],
+    "panels": [],
+    "proposals": []
+  }
+}

package/src/lib/plugin-runtime/examples/goal-task-creator/README.md

@@ -0,0 +1,60 @@
+# Goal task creator (source-only)
+
+This declaration-only plugin exports task-creation requests or submits pending
+creation drafts through separately authorized native connections. It requires a matching source build of the CLI,
+Session Core and desktop app. The compatibility floor in plugin.json does not
+mean the published CLI 0.166.142 already contains this command.
+
+From the repository root:
+
+```powershell
+cc plugin add packages/cli/src/lib/plugin-runtime/examples/goal-task-creator --scope project --json
+cc plugin trust goal-task-creator --scope project
+cc plugin consent goal-task-creator --scope project --grant --json
+cc goal draft-create-request <goal-id> --connection "<summary-connection.json>" --plugin goal-task-creator --scope project --source "<current-native-creation-proposal-id>" --request-id "<stable-id>" --title "Delivery follow-up" --task-type analyze_data --description-file "<description.txt>" --out "<new-create-request.json>" --json
+```
+
+Use a separately authorized goal summary connection to read the exact goal
+reference. Copy a current `task.create` risk proposal ID from the desktop;
+description proposal IDs cannot substitute for creation sources. Supported task
+types are `create_file`, `edit_file`, `query_info`, `analyze_data`, `export_file`
+and `deploy_project`. The file is an untrusted request, with no native draft,
+approval or task created by export. Existing output files are never overwritten.
+
+In the desktop's external-request panel, choose this request with the native file
+picker. Review the full description, task type and source before adopting it.
+Adoption stores only this pending draft under a native importer identity;
+the plugin name in the file is metadata, not proof of its origin. Task creation
+still requires a fresh native preview and a second explicit native confirmation.
+Creating the pending task does not execute it or prove the original risk resolved.
+
+Keep the same exported file after an uncertain adoption; reopen its saved record
+instead of exporting a new request identity. Revocation retains history and does
+not re-enable the old file. Online v3 description connections, the old description
+file schema and the combined assistant 0.2.0 do not gain creation permission.
+Matching source IDE builds provide **Export task creation request…** with a native
+type selector. There is no autonomous generation.
+
+For online pending drafts, allow goal creation suggestions and run a fresh risk
+check. Export a separate creation access file and select it from the desktop's
+**另行授权在线创建任务待审连接** control. Inspect the native consent and save a
+new private v6 connection:
+
+```powershell
+cc goal draft-create-access --plugin goal-task-creator --scope project --out "<new-creation-access.json>" --json
+cc goal draft-create-sources <goal-id> --connection "<creation-v6.json>" --plugin goal-task-creator --scope project --json
+cc goal draft-create-send <goal-id> --connection "<creation-v6.json>" --plugin goal-task-creator --scope project --source "<current-creation-source-id>" --request-id "<stable-id>" --title "Delivery follow-up" --task-type analyze_data --description-file "<description.txt>" --record "<new-submission.json>" --json
+cc goal draft-create-receipt <goal-id> --connection "<creation-v6.json>" --plugin goal-task-creator --scope project --record "<submission.json>" --json
+```
+
+Only a pending draft is saved. Actual task creation requires desktop preview and
+individual native confirmation. Preserve the same submission reference after
+an unknown response; an existing reference only queries, even on `not-found`.
+Task-type changes conflict with that request identity. Disconnect keeps drafts;
+native grant revocation invalidates unconfirmed work and preserves completed
+receipts. v3 description authority cannot substitute for v6 creation consent.
+Both source IDEs expose **Export online creation access…**, **Submit pending
+creation…** and **Look up creation receipt…** with native selectors. Creation
+results require successful exit and independent schema/action validation. After
+an interruption, use the same saved reference to query, without a new send.
+File export remains available. This requires matching unpublished source builds.

package/src/lib/plugin-runtime/examples/goal-task-creator/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "goal-task-creator",
+  "version": "0.1.0",
+  "description": "Export task creation requests for separate per-file native desktop adoption",
+  "permissions": { "goalExtension": ["proposal:task.create"] },
+  "goalExtension": {
+    "apiVersion": "1.0.0",
+    "hosts": { "cli": ">=0.166.143" },
+    "events": [],
+    "panels": [],
+    "proposals": ["task.create"]
+  }
+}