@synap-core/cli 1.11.0 → 1.13.0

package/dist/commands/market.d.ts

@@ -23,7 +23,9 @@
  */
 import { type CatalogEntry, type TemplateUpdateCheck } from "@synap-core/workspace-templates";
 import { type PackageFilters, type TierInfo } from "../lib/cp-packages.js";
-import { type InstalledTemplateInfo } from "../lib/installed.js";
+import { type InstalledKind, type InstalledRow, type InstalledTemplateInfo, type WorkspaceAttachment } from "../lib/installed.js";
+import { type TemplateUpdateStep } from "../lib/template-steps.js";
+import { type PendingDataChanges } from "../lib/template-lifecycle.js";
 export interface MarketCatalog {
     entries: CatalogEntry[];
     tierBySlug: Map<string, TierInfo>;
@@ -44,6 +46,8 @@ export interface MarketCatalog {
      */
     remoteVersionBySlug: Map<string, string>;
 }
+/** Drop workspace entries whose slug the CP retired. `null` (unknown) keeps every entry. */
+export declare function dropRetiredWorkspaces(entries: CatalogEntry[], retiredSlugs: Set<string> | null): CatalogEntry[];
 /**
  * Assemble the market catalog: bundled workspace templates ∪ public CP browse
  * (all types) ∪ the caller's own packages (when logged in), through the shared
@@ -52,9 +56,19 @@ export interface MarketCatalog {
  * the CP browse route (which needs no auth).
  */
 export declare function buildMarketCatalog(filters?: PackageFilters): Promise<MarketCatalog>;
-/** The `kind` values the pod's `market.install` verb provisions (see
- * cp-catalog-sync.ts `CatalogKind`). */
-export type MarketInstallKind = "capability" | "automation" | "template" | "cell";
+/**
+ * The `kind` values the pod's `market.install` verb provisions.
+ *
+ * SSOT: the `kind` zod enum of `marketInstallParams` in
+ * `synap-backend/packages/api/src/services/capabilities/builtin-verbs.ts`
+ * (each arm implemented in `marketplace-install.ts`). This list is a
+ * hand-maintained copy — `test/market-install-kind.test.ts` pins it against a
+ * copy of that enum so a widening on the pod cannot silently leave the CLI
+ * refusing a kind the verb accepts (which is exactly how `view` and `skill`
+ * became uninstallable from the CLI).
+ */
+export declare const MARKET_INSTALL_KINDS: readonly ["capability", "automation", "template", "cell", "skill", "view"];
+export type MarketInstallKind = (typeof MARKET_INSTALL_KINDS)[number];
 /**
  * Map a CP package `category` (what {@link typeOf} returns) → the pod
  * `market.install` verb's `kind` vocabulary, or `null` when the verb can't
@@ -66,6 +80,39 @@ export type MarketInstallKind = "capability" | "automation" | "template" | "cell
  * row already speaking the pod's cache vocabulary still resolves.
  */
 export declare function marketInstallKind(type: string): MarketInstallKind | null;
+/**
+ * Kinds whose `market.install` arm HARD-REQUIRES an acting workspace and 400s
+ * without one (`marketplace-install.ts`): an automation is added TO a workspace,
+ * and a view package needs a workspace to place its views in. Every other kind
+ * (capability / cell / skill) lands pod-wide — that branch is deliberate, so
+ * they must NOT be added here.
+ */
+export declare function marketInstallNeedsWorkspace(kind: MarketInstallKind): boolean;
+/** One per-item result of a kind:automation market.install (marketplace-install.ts). */
+export type ItemInstallResult = {
+    name?: string;
+    status?: string;
+    message?: string;
+};
+/**
+ * Classify the PER-ITEM results of a kind:automation (workflow) install.
+ *
+ * The backend `market.install` automation case installs each automation under
+ * its own try/catch (per-item isolation), so the verb can report the overall
+ * install as `{status:"installed"}` while individual items are
+ * `{status:"error"}`. The CLI must inspect these before printing success — a
+ * bare "✓ Installed" is a lie when every item errored (the false-success bug).
+ *
+ * Returns null for any outcome that carries NO per-item array (cell, skill,
+ * workspace, …) so the caller falls through to the unchanged success line.
+ * Reads `automations[]` (the automation kind's field) or a generic `results[]`.
+ */
+export declare function summarizeItemInstall(installed: Record<string, unknown>): {
+    created: number;
+    reused: number;
+    errored: ItemInstallResult[];
+    okCount: number;
+} | null;
 interface DependencySeedOutcome {
     slug: string;
     status: "no-layers" | "seeded" | "failed";
@@ -96,13 +143,92 @@ export interface WorkspaceApplyResult {
     workspaceId?: string;
     onto?: string;
     outcome?: "created" | "reconciled" | "unchanged";
+    /**
+     * Per-layer install outcomes, `status.conditions[]`-shaped, added pod-side on
+     * 2026-09-06 (`services/capabilities/install-layers.ts`).
+     *
+     * The pod already KNEW when a workspace landed but its capabilities,
+     * playbooks or automations did not — `applyPackagePostWorkspace` stamps the
+     * failure into `workspace.settings` — but `createFromDefinition` swallowed the
+     * rethrow and returned a clean report, so this CLI printed a bare
+     * "✓ Installed" for an install whose every capability had failed. Projecting
+     * the failure without reading it here would just move the lie one layer out.
+     *
+     * OPTIONAL because an older pod does not send it. Absent means "this pod
+     * cannot tell me", NOT "nothing failed" — so absence never downgrades the
+     * verdict, and the pre-existing `seedFailed` signal remains the fallback.
+     */
+    layers?: InstallLayerReport[];
 }
+/**
+ * One install layer's outcome, as the pod reports it.
+ *
+ * ⚠️ The failure text field is `message`, NOT `detail`. The pod's SSOT
+ * (`InstallLayerReport` in `@synap/database`'s
+ * `reconcile-workspace-from-definition.ts`) declares `message`, and all four
+ * producers write it — `summarizePostWorkspaceLayers`
+ * (`services/capabilities/install-layers.ts`, the ONE derivation) plus the three
+ * hand-pushed failed layers in `routers/workspaces/definition-engine.ts`. This
+ * mirror declared `detail`, a field the wire never carries — so `printLayerOutcomes`
+ * printed "no detail reported" on EVERY failed layer, and because the mirror is
+ * local, tsc could never see the drift.
+ */
+export interface InstallLayerReport {
+    layer?: string;
+    status?: string;
+    message?: string;
+}
+/**
+ * True when the pod reported a FAILED install layer.
+ *
+ * Reads `status` explicitly rather than inferring failure from the absence of a
+ * success marker: an unrecognised status is not a failure, and an absent
+ * `layers` array is not a success. Both are simply "not a reported failure",
+ * which is what the pre-existing `seedFailed` path already covers.
+ */
+export declare function hasLayerFailure(layers: InstallLayerReport[] | undefined): boolean;
+/**
+ * Print an honest per-dependency seed summary — no more silent "✓ ready" when
+ * a dependency's capabilities/playbooks failed to seed. Prefers the top-level
+ * `seedSummary` rollup when present (pre-aggregated by the backend); falls
+ * back to re-deriving from the per-dependency `dependencies[]` array on older
+ * pod builds. No-op when there's nothing to report.
+ */
+/**
+ * Name the install layers the pod reported as FAILED.
+ *
+ * The verdict line already says "some capabilities failed"; without
+ * this the user is told something failed and never which thing — the same
+ * complaint that made `install-layers.ts` fall back from `name` to `key`.
+ * Silent when the pod sent no layers (an older pod) or none failed.
+ */
+export declare function printLayerOutcomes(layers: InstallLayerReport[] | undefined): void;
 export interface ApplyVerdict {
     /** Honest coarse status — JSON consumers should branch on this, never guess from `workspace.outcome` alone. */
-    status: "installed" | "installed-with-failures" | "updated" | "updated-with-failures" | "unchanged" | "composed" | "composed-with-failures" | "stamp-contradiction" | "legacy-unknown" | "no-workspace";
-    /** Non-fatal warnings — a stamp contradiction or a compose-overlay note. Seed failures are reported separately via `printSeedOutcomes`. */
+    status: "installed" | "installed-with-failures" | "updated" | "updated-with-failures" | "unchanged" | "composed" | "composed-with-failures" | "not-finished" | "awaiting-approval" | "stamp-contradiction" | "legacy-unknown" | "no-workspace";
+    /** Non-fatal warnings — a stamp contradiction, a compose-overlay note, or the next step of an unfinished apply. Seed failures are reported separately via `printSeedOutcomes`. */
     warnings: string[];
 }
+/**
+ * How far the pod says layer 2 got, read from the `/packages/apply` response
+ * (synap-backend `hub-protocol/rest/packages.ts`): a thrown layer 2 arrives as
+ * `layer2: {status: "failed"}`, an unconverged one as the `templateApply`
+ * record, and either way the pod's sentence as `templateApplyWarning`.
+ * `null` = the pod reported nothing unfinished (converged, or an older pod).
+ */
+export declare function podApplyState(res: Record<string, unknown>): "not-finished" | "awaiting-approval" | null;
+/**
+ * The verdict of one `/packages/apply` response — the ONE reader both
+ * `marketInstall` and `applyOnePackage` call. Layer 2's outcome comes from the
+ * pod's own state (`podApplyState`): an apply the pod says is unfinished is
+ * never "updated", and never a stamp contradiction (the pod held the version
+ * on purpose — redeploying fixes nothing).
+ */
+export declare function classifyApplyResponse(entry: CatalogEntry, res: Record<string, unknown>, ctx: {
+    remoteVersionSent?: string;
+    wasUnstamped: boolean;
+    stampVerified?: boolean | null;
+}): ApplyVerdict;
 /**
  * Classify one `/packages/apply` response into the honest verdict both
  * `marketInstall` and `applyOnePackage` print (and both put in `--json`).
@@ -114,7 +240,32 @@ export interface ApplyVerdict {
 export declare function classifyApplyResult(entry: CatalogEntry, ws: WorkspaceApplyResult | undefined, dependencies: ResolvedDependencyLike[] | undefined, seedSummary: SeedSummary | undefined, ctx: {
     remoteVersionSent?: string;
     wasUnstamped: boolean;
+    stampVerified?: boolean | null;
+    /** The pod HELD the version on purpose (`templateApply` in the response): not a contradiction. */
+    stampHeld?: boolean;
 }): ApplyVerdict;
+/**
+ * An action button the template places on a record page, held back because the
+ * playbook (or automation) it launches is waiting on a proposal — the pod's
+ * `actionPlacements.deferred[]` on `/packages/apply`. The button appears on the
+ * next update once that proposal is approved.
+ */
+export interface DeferredPlacement {
+    kind?: string;
+    ref?: string;
+    label?: string;
+    proposalId?: string;
+}
+/** One plain line per deferred placement; `[]` when none (or an older pod). */
+export declare function deferredPlacementLines(res: Record<string, unknown>): string[];
+/**
+ * Why the pod did NOT record the template version — the pod's ONE sentence
+ * (`templateApplyWarning` on the `/packages/apply` response, synap-backend
+ * `templateApplyWarning`): the same words `synap templates` keeps showing under
+ * the space. Printed verbatim; `null` when the version was recorded (or an
+ * older pod that does not say).
+ */
+export declare function heldVersionLine(res: Record<string, unknown>): string | null;
 /** Render a `classifyApplyResult` verdict — the ONE honest-text door for both `marketInstall` and `applyOnePackage`. */
 export declare function printApplyVerdict(entry: CatalogEntry, verdict: ApplyVerdict): void;
 export declare function market(opts: {
@@ -133,7 +284,39 @@ export declare function marketInstall(slug: string, opts: {
     onto?: string;
     /** Preview the create path write-free (`/packages/preflight`) — reports would-create / reuse / conflicts and writes nothing. */
     dryRun?: boolean;
+    /** Acting workspace (UUID) an `automation`/`workflow` install is added TO — the
+     * backend `market.install` verb requires one for that kind (an automation
+     * lives in a workspace). Defaults to the active lens (`synap use` / env); a
+     * pod-wide kind (cell/capability) ignores it. */
+    workspace?: string;
 }): Promise<void>;
+/** The definition a workspace install sends, and the version label it carries. */
+export interface InstallPayload {
+    pkg: Record<string, unknown>;
+    /** Where `pkg` came from. */
+    from: "catalog" | "bundle";
+    /**
+     * The CATALOG version, set ONLY when `pkg` is that catalog row's own
+     * definition — the one value the CLI may expect the pod to stamp. Never set
+     * for a bundled definition (incident 2026-10-06: the bundle's OLD content-os
+     * went out labelled with the catalog's `h-448ffcae9220`, and the pod recorded
+     * a stale layout as up to date).
+     */
+    catalogVersion?: string;
+}
+/**
+ * Pick the install definition through the SAME winner rule the catalog uses
+ * (`mergeCatalog`: an official CP row wins over this CLI's frozen bundle only
+ * when its `definition.sourcePackage.version` is strictly newer), and label it
+ * honestly: a catalog definition carries the catalog version; a bundled one
+ * carries the bundle's own package version (`bundle@x.y.z`), never the
+ * catalog's. The pod re-derives the stamp from what it applied either way.
+ *
+ * Returns `null` only for a non-bundled slug whose definition could not be
+ * fetched (the caller reports it). A failed fetch for a BUNDLED slug falls back
+ * to the bundle — the documented offline path — labelled as the bundle.
+ */
+export declare function resolveInstallPayload(slug: string, cat: Pick<MarketCatalog, "bundledSlugs" | "remoteVersionBySlug" | "reachedCp">, cpToken: string | undefined): Promise<InstallPayload | null>;
 export interface UpdateCheck extends TemplateUpdateCheck {
     /**
      * True when the installed workspace carries no version stamp at all — the
@@ -142,24 +325,87 @@ export interface UpdateCheck extends TemplateUpdateCheck {
      * see `InstalledTemplateInfo.version`'s doc in `lib/installed.ts`.
      */
     noVersionInfo: boolean;
+    /** The installed row's kind (absent = `"workspace"`, the only kind an older pod reports). Picks the update door — see {@link updateDoorFor}. */
+    kind?: InstalledKind;
 }
 /**
- * Per-installed-slug drift check. Starts from the shared `computeTemplateUpdates`
- * (handles bundled-only / private-only slugs via `bundleVersion`), then
- * overrides `latestVersion`/`updateAvailable` with the CP row's OWN version for
- * any slug in `remoteVersionBySlug` — the merge-winner bypass this command
- * needs (see `MarketCatalog.remoteVersionBySlug`'s doc). A slug the pod never
- * version-stamped is reported `noVersionInfo: true`, never silently "outdated".
+ * Which pod door UPDATES an installed package of this kind, or `null` when the
+ * pod has no per-package updater for it.
+ *
+ * ⚠️ Never default to `/packages/apply`. That is the WORKSPACE door: it mints a
+ * workspace for any body carrying a `_meta.slug`. On 2026-10-12 `market update`
+ * sent the `creative-director` SKILL through it and the pod created an empty
+ * "New Workspace" — the update-time twin of the 2026-09-05 install bug that
+ * {@link declaredCategoryOf} fixed.
+ *
+ *  - view / skill / automation converge through the source-linked 3-way-merge
+ *    reconcile (`POST /configs/reconcile`) — the SAME comparator whose dry run
+ *    marked the row drifted (`GET /installed?drift`). Re-running `market.install`
+ *    is not an update: the skill arm always creates (unique slug ⇒ fails), the
+ *    automation arm returns "reused".
+ *  - cell / capability have no per-package updater here: `null`.
+ */
+export type UpdateDoor = "packages-apply" | "configs-reconcile";
+export declare function updateDoorFor(kind: InstalledKind | undefined): UpdateDoor | null;
+/**
+ * Per-installed-slug drift check. SERVER-FIRST: when the pod runs the
+ * server-side TemplateHealth code (Hub `/workspaces` returns `drifted`/
+ * `latestVersion`), that verdict wins — the CLI stops re-deriving drift, so it
+ * can't disagree with the pod (or the browser, which reads the same authority).
+ *
+ * FALLBACK (older pod, `drifted === undefined`): the legacy client derivation —
+ * the shared `computeTemplateUpdates` (handles bundled-only / private-only slugs
+ * via `bundleVersion`), then override `latestVersion`/`updateAvailable` with the
+ * CP row's OWN version for any slug in `remoteVersionBySlug` (the merge-winner
+ * bypass). A slug the pod never version-stamped is `noVersionInfo: true`, never
+ * silently "outdated".
  */
 export declare function computeUpdates(installedTemplates: InstalledTemplateInfo[], cat: MarketCatalog): UpdateCheck[];
+/** First check per slug, order preserved — an update is applied per PACKAGE, not per installed object. */
+export declare function dedupeBySlug(checks: UpdateCheck[]): UpdateCheck[];
 export declare function marketUpdate(slugsArg: string[] | undefined, opts: {
+    /** The literal `--yes` flag: apply every update AND agree to every data change listed. */
     yes?: boolean;
+    /** `update all`: apply every update — data changes still need agreement (asked, or flagged). */
+    all?: boolean;
+    /** `--accept-data-changes a,b`: agree to exactly these opKeys. */
+    acceptDataChanges?: string;
     dryRun?: boolean;
     json?: boolean;
     podUrl?: string;
     apiKey?: string;
     timeout?: string;
 }): Promise<void>;
+/**
+ * One-line rollup over a batch of `applyOnePackage` outcomes — computed from
+ * the SAME per-item `status` (`classifyApplyResult`'s honest verdict) the
+ * loop already collects, not a separate tally. `"installed"`/`"updated"`/
+ * `"composed"`/`"legacy-unknown"` count as a clean update, `"unchanged"` as
+ * already-current, the `*-with-failures` and `"stamp-contradiction"` statuses
+ * get their OWN bucket — a partial capability-seed failure or a stamp that
+ * silently didn't take is never folded into a clean "updated" count.
+ * `"timed-out"` is broken out from the generic `"failed"` bucket; everything
+ * else (locked/proposed/fetch-failed/not-in-catalog/no-workspace/unknown)
+ * rolls into "failed".
+ */
+export declare function summarizeApplyResults(results: Array<{
+    slug: string;
+    status: string;
+}>): {
+    updated: number;
+    unchanged: number;
+    withFailures: number;
+    failed: number;
+    timedOut: number;
+    proposed: number;
+    needsConsent: number;
+    line: string;
+};
+/**
+ * Human status cell for one installed row — distinguishes hash drift (no
+ * ordering, just "changed") from semver drift ("update available").
+ */
+export declare function installedStatusLabel(c: UpdateCheck, isPrivate: boolean, loggedIn: boolean): string;
 export interface TreeNode {
     slug: string;
     name: string;
@@ -210,15 +456,153 @@ export declare function buildCompositionTrees(rows: UpdateCheck[], cat: MarketCa
 }>;
 export declare function printCompositionTree(pkg: TreePackage): void;
 /**
- * Pure-read inventory of what's installed on this pod — reuses
- * `buildMarketCatalog` + `fetchInstalledTemplates` + `computeUpdates`
- * (`market update`'s own drift check), never writes anything. Pairs with
- * `market update` to apply what this surfaces.
+ * "3 workspaces" / "pod-wide" / "2 workspaces · pod-wide" — where a slug landed.
+ *
+ * Counts DISTINCT placements, not rows. Since `GET /installed` reports one row
+ * per installed OBJECT (four `task-views-pack` views across two workspaces is
+ * four rows), tallying rows would have printed "4 workspaces" for two. The
+ * workspace-kind rows this replaced are one-per-workspace either way, so their
+ * output is unchanged.
+ */
+export declare function fanOutLabel(placements: Set<string>): string;
+/**
+ * One INVENTORY-ONLY row — installed, source-linked, but NOT to a package slug,
+ * so `market update` structurally cannot act on it. Every `capability` row is
+ * one of these (its link is a CP template key), as is any cell whose type key
+ * carried the `"unknown"` sentinel.
+ *
+ * They are listed, never hidden: an unlisted install is exactly the blindness
+ * this door was built to remove. They are just kept OUT of the update table so
+ * nothing offers a slug the catalog does not have.
  */
+export interface UnlinkedInstall {
+    kind: InstalledKind;
+    /** The CP template key, or null when the row has no source link at all. */
+    templateKey: string | null;
+    name: string;
+    placements: Set<string>;
+    note?: string;
+}
+/** Dedupe the not-package-linked rows by `kind + templateKey` (falling back to the row name). */
+export declare function collectUnlinked(rows: InstalledRow[]): UnlinkedInstall[];
 export declare function marketInstalled(opts: {
     json?: boolean;
     outdated?: boolean;
     tree?: boolean;
     layers?: boolean;
 }): Promise<void>;
+type AttachmentStatus = {
+    kind: "unattached";
+} | {
+    kind: "no-version";
+    slug: string;
+}
+/** Attached, no version recorded, and the pod reads it drifted: its last install/update did not finish (the pod holds the version until it does). */
+ | {
+    kind: "unfinished";
+    slug: string;
+} | {
+    kind: "attached";
+    slug: string;
+    version: string;
+    updateAvailable: boolean;
+    latestVersion?: string;
+};
+/** Human status cell for one workspace row — the same vocabulary as `market installed`, keyed on attachment. */
+export declare function attachmentStatusLabel(s: AttachmentStatus): string;
+/**
+ * Pure-read discovery surface — every workspace on the pod with its template-
+ * attachment status. Sources the linkage from the SAME Hub `GET /workspaces`
+ * call `market installed` uses (`fetchWorkspaceAttachments`), and reuses
+ * `computeUpdates` for the stamped-drift verdict. Never writes.
+ */
+export declare function marketWorkspaces(opts: {
+    json?: boolean;
+    unattached?: boolean;
+}): Promise<void>;
+export declare function marketAttach(workspaceId: string, opts: {
+    slug?: string;
+    project?: string;
+    timeout?: string;
+    json?: boolean;
+    podUrl?: string;
+    apiKey?: string;
+}): Promise<void>;
+interface TemplateSuggestion {
+    slug: string;
+    name: string;
+    /** "strong" = exact domain match (safe to auto-fill on --yes); "weak" = the name looks like it (confirm first). */
+    confidence: "strong" | "weak";
+}
+/** Best template guess for an unattached workspace: exact domain match wins; else the name containing a template slug. Null when nothing fits — we never invent a link. */
+export declare function suggestTemplateFor(ws: WorkspaceAttachment, entries: CatalogEntry[]): TemplateSuggestion | null;
+type WorkspaceResolution = {
+    kind: "found";
+    ws: WorkspaceAttachment;
+} | {
+    kind: "none";
+} | {
+    kind: "ambiguous";
+    matches: WorkspaceAttachment[];
+};
+/** Resolve a user-typed workspace reference — exact id, else exact (case-insensitive) name, else a UNIQUE substring name match. No silent pick when >1 fits. */
+export declare function resolveWorkspaceQuery(query: string, attachments: WorkspaceAttachment[]): WorkspaceResolution;
+type TemplateRowGroup = "attention" | "ok" | "unlinked";
+export interface TemplateRow {
+    ws: WorkspaceAttachment;
+    status: AttachmentStatus;
+    suggestion: TemplateSuggestion | null;
+    group: TemplateRowGroup;
+    /** The exact next command for this row — null for a row with no action (current, or unlinked with no confident match). */
+    action: string | null;
+    /** The template is not `current` on the pod (retired / unlisted / catalog not fully synced) — null when current or on an older pod. */
+    lifecycleNotice: {
+        label: string;
+        action: string | null;
+    } | null;
+    /** One line per overlay on the space, with its notice when not `current`. Empty on an older pod. */
+    overlayNotices: Array<{
+        slug: string;
+        label: string | null;
+        lifecycle: string;
+    }>;
+    /** The pod's sentence for why the last update did not finish (`applyWarning`) — null when there is nothing to say. */
+    applyNotice: string | null;
+    /** The space's leading step (`classifyTemplateStep`, the shared rule + precedence) — null when current. */
+    step: TemplateUpdateStep | null;
+    /** Data changes the update waits on the person to agree to — null when none (or an older pod). */
+    dataChanges: PendingDataChanges | null;
+    /** An agent's pending "update this space" proposal — null when none (or an older pod). */
+    updateProposalId: string | null;
+}
+/** Sort one workspace into the action-ranked home: drifted / unstamped / (unattached-with-suggestion) → attention; current → ok; unattached-no-match → unlinked. */
+export declare function classifyTemplateRow(ws: WorkspaceAttachment, check: UpdateCheck | undefined, entries: CatalogEntry[]): TemplateRow;
+export declare function renderTemplateRow(r: TemplateRow): void;
+/**
+ * `synap templates` — grouped, action-ranked view of every workspace's template
+ * link. Default surfaces "Needs attention" first (drifted + unattached-with-
+ * suggestion + unstamped), then up-to-date, then unlinked. `--needs-attention`
+ * shows only the first group; `--json` for scripts. Pure read.
+ */
+export declare function marketTemplates(opts: {
+    json?: boolean;
+    needsAttention?: boolean;
+    podUrl?: string;
+    apiKey?: string;
+}): Promise<void>;
+/**
+ * `synap templates attach <workspace>` — the ONE natural connect command. Takes a
+ * workspace NAME (or id), suggests the template, confirms once. `--slug` forces a
+ * specific template; `--yes` accepts a strong suggestion non-interactively.
+ * Hands the actual reconcile+stamp to the same door `market install --onto` uses.
+ */
+export declare function templatesAttach(query: string, opts: {
+    slug?: string;
+    yes?: boolean;
+    project?: string;
+    timeout?: string;
+    json?: boolean;
+    podUrl?: string;
+    apiKey?: string;
+}): Promise<void>;
 export {};