🧪 Verify the complete terminal-grid stack on main (#717)

.github/workflows/publish-packages.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Validate the manifests declare this version
         run: |
           VERSION="${{ steps.resolve.outputs.value }}"
-          for f in packages/durable-streams/deno.json packages/runtime/deno.json packages/core/deno.json packages/acp/deno.json packages/testing/deno.json packages/test-agent/deno.json packages/web/deno.json packages/workflow/deno.json packages/cli/deno.json packages/code-review-agent/deno.json; do
+          for f in packages/durable-streams/deno.json packages/runtime/deno.json packages/terminal/deno.json packages/core/deno.json packages/acp/deno.json packages/terminal-tmux/deno.json packages/testing/deno.json packages/test-agent/deno.json packages/web/deno.json packages/workflow/deno.json packages/cli/deno.json packages/code-review-agent/deno.json; do
             declared="$(jq -r .version "$f")"
             if [ "$declared" != "$VERSION" ]; then
               echo "::error::$f declares $declared, not $VERSION — the tag does not match the manifests"
@@ -75,20 +75,34 @@ jobs:
       package: packages/runtime
       version: ${{ needs.version.outputs.value }}
 
+  terminal:
+    needs: [version, durable-streams]
+    uses: ./.github/workflows/publish-one.yml
+    with:
+      package: packages/terminal
+      version: ${{ needs.version.outputs.value }}
+
   core:
-    needs: [version, durable-streams, runtime]
+    needs: [version, durable-streams, runtime, terminal]
     uses: ./.github/workflows/publish-one.yml
     with:
       package: packages/core
       version: ${{ needs.version.outputs.value }}
 
   acp:
-    needs: [version, core, runtime]
+    needs: [version, core, runtime, terminal]
     uses: ./.github/workflows/publish-one.yml
     with:
       package: packages/acp
       version: ${{ needs.version.outputs.value }}
 
+  terminal-tmux:
+    needs: [version, terminal]
+    uses: ./.github/workflows/publish-one.yml
+    with:
+      package: packages/terminal-tmux
+      version: ${{ needs.version.outputs.value }}
+
   testing:
     needs: [version, core, durable-streams, runtime]
     uses: ./.github/workflows/publish-one.yml
@@ -97,7 +111,7 @@ jobs:
       version: ${{ needs.version.outputs.value }}
 
   test-agent:
-    needs: [version, acp, core, durable-streams, runtime, testing]
+    needs: [version, acp, core, durable-streams, runtime, terminal, testing]
     uses: ./.github/workflows/publish-one.yml
     with:
       package: packages/test-agent
@@ -118,7 +132,7 @@ jobs:
       version: ${{ needs.version.outputs.value }}
 
   cli:
-    needs: [version, acp, core, durable-streams, runtime, test-agent, testing, web, workflow]
+    needs: [version, acp, core, durable-streams, runtime, terminal, terminal-tmux, test-agent, testing, web, workflow]
     uses: ./.github/workflows/publish-one.yml
     with:
       package: packages/cli

packages/acp/mod.ts

@@ -42,15 +42,35 @@ export {
   ADVERTISED_NATIVE_LAUNCH,
   knownNativeAdapters,
   nativeAdapterFor,
+  nativeCapabilityPolicy,
 } from "./src/native-launch.ts";
 export { allocatesIdentity } from "./src/native-launch.ts";
 export type {
   ClientAllocatedAdapter,
   NativeAdapter,
   NativeBinding,
+  NativeCapabilityProbe,
+  ProbedNativeCapabilities,
   ProviderReturnedAdapter,
 } from "./src/native-launch.ts";
 
+/**
+ * Which protocol shapes and machines a native capability is admitted on.
+ *
+ * Public because the host is what states them: it supplies its own OS and
+ * architecture beside the coordinator and the observer, and shared provider
+ * code must not detect either for itself.
+ */
+export { admitsNativeCapability } from "./src/native-capability.ts";
+export type {
+  NativeCapability,
+  NativeCapabilityAdmission,
+  NativeCapabilityHost,
+  NativeCapabilityPolicy,
+  ObservedNativeCapability,
+  ProvedNativeCapability,
+} from "./src/native-capability.ts";
+
 /**
  * ACPX's own runtime types.
  *

packages/acp/package.json

@@ -11,6 +11,7 @@
     "@agentclientprotocol/sdk": "1.3.0",
     "@executablemd/core": "workspace:*",
     "@executablemd/runtime": "workspace:*",
+    "@executablemd/terminal": "workspace:*",
     "acpx": "0.12.0",
     "effection": "4.1.0"
   }

packages/acp/src/native-capability.ts

@@ -0,0 +1,98 @@
+/**
+ * What one real-CLI proof admits, and nothing wider (specs/decisions.md
+ * DEC-017).
+ *
+ * An Agent name says which command shape to consider. It does not say that the
+ * thing found under that name works: a proof ran against one implementation's
+ * protocol, on one operating system, on one architecture, and every other
+ * protocol and machine is a claim nobody made. So admission is stated as
+ * profiles, and a profile is the whole tuple —
+ *
+ *   adapter protocol + capability + observed probe profile + host OS + host
+ *   architecture
+ *
+ * — matched exactly. Nothing here is a version. A version says which release
+ * was installed, not what it can do, and admitting one would make a routine
+ * upgrade disable every new session while telling nobody why. What is matched
+ * instead is the adapter's stable protocol identifier and what its own
+ * side-effect-free probe recognized in the exact executable that was hashed.
+ *
+ * The host pair is supplied rather than read. Which machine this is is a fact
+ * the trusted host has and shared provider code must not go looking for: a
+ * provider that detected its own runtime would answer the admission question
+ * with the thing being asked about.
+ */
+
+/**
+ * Which behavior a proof established.
+ *
+ * Two, not one, because they are proved separately: handing a session to a
+ * native UI and later joining that same conversation through ACP are different
+ * things that can be true independently.
+ */
+export type NativeCapability = "native-launch" | "client-native-attachment";
+
+/** The machine a host is actually running on, as that host states it. */
+export interface NativeCapabilityHost {
+  readonly platform: string;
+  readonly architecture: string;
+}
+
+/** One capability, proved for one protocol shape on one exact machine. */
+export interface NativeCapabilityAdmission {
+  /**
+   * The adapter implementation whose protocol was proved.
+   *
+   * Deliberately not the Agent registry name and not the launcher command:
+   * either can be pointed at something else, and neither says which protocol
+   * the thing behind it speaks.
+   */
+  readonly adapterProtocol: string;
+  readonly capability: NativeCapability;
+  /** The probe whose recognized shape this admission was proved against. */
+  readonly probeProfile: string;
+  readonly platform: string;
+  readonly architecture: string;
+}
+
+/** Everything a host admits, beside the machine it admits it on. */
+export interface NativeCapabilityPolicy {
+  readonly host: NativeCapabilityHost;
+  readonly admissions: readonly NativeCapabilityAdmission[];
+}
+
+/** What an adapter carries about its own proofs, before a host names a machine. */
+export type ProvedNativeCapability = Omit<NativeCapabilityAdmission, "adapterProtocol">;
+
+/** The live capability an observation offers for admission. */
+export interface ObservedNativeCapability {
+  readonly adapterProtocol: string;
+  readonly capability: NativeCapability;
+  readonly probeProfile: string;
+}
+
+/**
+ * Whether this host admits what was actually observed.
+ *
+ * The host's own OS and architecture are what an admitted profile is compared
+ * against, so a profile proved elsewhere cannot admit anything here. An absent
+ * policy admits nothing: a host that states no proof has none, and treating
+ * silence as permission is the failure this whole tuple exists to prevent.
+ */
+export function admitsNativeCapability(
+  policy: NativeCapabilityPolicy | undefined,
+  observed: ObservedNativeCapability,
+): boolean {
+  if (policy === undefined) {
+    return false;
+  }
+  const { platform, architecture } = policy.host;
+  return policy.admissions.some(
+    (admission) =>
+      admission.adapterProtocol === observed.adapterProtocol &&
+      admission.capability === observed.capability &&
+      admission.probeProfile === observed.probeProfile &&
+      admission.platform === platform &&
+      admission.architecture === architecture,
+  );
+}