@sayknow-cli/coding-agent 0.5.11 → 0.5.14

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [0.5.14] - 2026-09-16
+
+### Added
+
+- Bundled frontend UI/UX craft skills so SKC sessions can invoke them without a separate user install: Emil Kowalski's web craft set (`emil-design-eng`, `animate`, `review-animations`, `improve-animations`, `find-animation-opportunities`, `pick-ui-library`, `prototype`, `mobile-native`, `animation-vocabulary`, `apple-design`, `ask-sonner`) and Appllama's native mobile build bar (`appllama-app-design-skill`). These are not public workflow skills; the four workflows remain `deep-interview`, `ralplan`, `ultragoal`, and `team`. `appllama-usage` is deliberately excluded because it only drives the paid Appllama MCP, which SKC does not ship. Each skill's companion reference files are inlined as appendices by `scripts/build-ui-skill-bundle.ts`, since only `SKILL.md` is compiled into the binary and a bundled skill's `baseDir` is a virtual path.
+- The native `UserPromptSubmit` hook routes frontend UI/UX prompts to the matching bundled UI skill automatically, in English and Korean, so the agent loads `animate`, `review-animations`, `pick-ui-library`, `mobile-native`, `appllama-app-design-skill`, `ask-sonner`, or the `emil-design-eng` baseline without the user naming a skill. Detection is additive to workflow-keyword activation, seeds no workflow mode state, and stays silent for non-frontend prompts and for SKC's own terminal-only UI work.
+- Transition-shaped prompts route to the `transitions-dev` skill ([transitions.dev](https://github.com/Jakubantalik/transitions.dev)). When it is absent the agent installs it itself with upstream's own non-interactive command (`-a universal`, landing in `<project>/.agents/skills/`, a root SKC loads) through the `bash` tool, so the user never types an install command; when present it is loaded directly. The collection is deliberately **not** vendored: upstream licenses only its CLI and Refine tooling under MIT, while the transitions carry a clause forbidding repackaging or publishing the collection — which is what bundling into the SKC binary would do. Installing into the user's own project is explicitly permitted.
+- `skc setup ui-skills` installs the routed-but-unbundled frontend skills into the current project (`<project>/.agents/skills/`, a root SKC's agents provider loads), with `--check` to audit and `--force` to reinstall. It runs upstream's own publisher CLI and verifies the payload landed, so a silent installer failure is reported instead of being treated as success.
+- Animated-React-component prompts route to a new bundled `react-bits` skill covering the [React Bits](https://reactbits.dev) registry: when to reach for it, the per-component `npx shadcn@latest add @react-bits/<Component>-<Variant>` install, the `components.json` precondition that otherwise hangs a non-interactive run, post-install duties (dependency weight, reduced-motion guards), and a catalog of all 169 component names. The skill is SKC-authored guidance plus factual metadata — React Bits ships no agent skill of its own, and its MIT + Commons Clause license forbids redistributing the components, so no component source is bundled.
+
+### Fixed
+
+- Runtime skill discovery ranks project `.skc/skills` ahead of the user-home catalog before applying the result limit, so a populated `~/.skc/skills` cannot hide a project skill (ported from upstream v0.16.5 skill-convention budget ranking).
+- Session-import URL redaction no longer caps the scheme at 16 characters. The scheme-character run is boundary-anchored so long and digit-prefixed credential URLs still redact without quadratic scanning (ported from upstream #5402).
+
+## [0.5.13] - 2026-09-15
+### Fixed
+
+- Session-import's cross-process idempotency test no longer depends on Bun child stdout surviving a contended file lock. The child writes its result to a file as well as stdout, so a silent empty pipe on Linux CI cannot fail a successful import.
+
+
+## [0.5.12] - 2026-09-15
+### Added
+
+- `skc ultragoal succession offer|adopt|status` gives an approved Ultragoal an explicit, audited path from the repository it was planned in to the repository its implementation belongs to (ported from upstream #5353). The source run fences the selected unfinished goals immediately; the target adopts a fresh pending plan with verbatim brief/objectives and unresolved obligations as provenance, not inherited completion authority.
+- Custom OpenAI-compatible providers in `models.yml` auto-populate `/model` from their live `/v1/models` catalog without a manual `discovery:` block, and auto-classify each discovered model's wire API family (ported from upstream #5187). Explicit `discovery` config and the local `openaiCompat` proxy lane are unchanged.
+
+### Fixed
+
+- Session import redaction now bounds the URL-credential scheme to 16 characters so large credential-free transcripts scan in linear time instead of quadratic (ported from upstream #5346). Markdown-wrapped `https://user:pass@host` credentials remain redacted.
+- File-lock acquisition timeouts are a typed `FileLockAcquireError` with the lock path, retry count, and holder, instead of an untyped string. Empty `.lock` directories left by a crash between `mkdir` and writing `info` are reclaimable by GC (the SKC-shaped subset of upstream #5378/#5381; this tree has no `.lock.pending.<pid>.<uuid>` staging).
+- `writeGuardedJsonAtomic` honors `lockHeld`, so callers already inside `withWorkflowStateLock` (succession offer/adopt, start/checkpoint) no longer self-deadlock.
+- Under tmux, a successful sixel DA1 no longer turns INLINE transcript images back on. Ghostty answers that query with ";4" even though it never paints sixel, so every screenshot was smuggled through DCS passthrough onto the outer image plane and stacked over the chat. The probe now enables overlay sixel (the pet) only; inline sixel stays off unless tmux itself owns `terminal-features=sixel`.
+
+
 ## [0.5.11] - 2026-09-10
 
 ### Fixed

package/dist/types/cli/setup-cli.d.ts

@@ -5,7 +5,7 @@
  */
 import { AuthStorage, SqliteAuthCredentialStore } from "@sayknow-cli/ai";
 import { runExternalCredentialAutoImport } from "../setup/credential-auto-import";
-export type SetupComponent = "claude" | "codex" | "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+export type SetupComponent = "claude" | "codex" | "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt" | "ui-skills";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {

package/dist/types/config/file-lock.d.ts

@@ -3,6 +3,14 @@ export interface FileLockOptions {
     retries?: number;
     retryDelayMs?: number;
 }
+export declare class FileLockAcquireError extends Error {
+    readonly filePath: string;
+    readonly lockPath: string;
+    readonly attempts: number;
+    readonly holder: string;
+    readonly code = "acquire_timeout";
+    constructor(filePath: string, lockPath: string, attempts: number, holder: string);
+}
 /**
  * Returns the OS-provided process start timestamp for PID-reuse detection.
  * `ps` is available on the supported Unix hosts (macOS and Linux), unlike

package/dist/types/config/model-registry.d.ts

@@ -97,6 +97,7 @@ export declare const ModelsConfigFile: ConfigFile<{
         auth?: "none" | "apiKey" | "oauth" | undefined;
         discovery?: {
             type: "ollama" | "lm-studio" | "omlx" | "sglang" | "llama.cpp" | "openai-models-list";
+            apiByModelPrefix?: Record<string, string> | undefined;
         } | undefined;
         requestTransform?: {
             profile?: "openai-proxy" | undefined;

package/dist/types/config/models-config-schema.d.ts

@@ -265,6 +265,7 @@ export declare const ProviderDiscoverySchema: z.ZodObject<{
         "llama.cpp": "llama.cpp";
         "openai-models-list": "openai-models-list";
     }>;
+    apiByModelPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export declare const ProviderAuthSchema: z.ZodEnum<{
     none: "none";
@@ -375,6 +376,7 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                 "llama.cpp": "llama.cpp";
                 "openai-models-list": "openai-models-list";
             }>;
+            apiByModelPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strip>>;
         requestTransform: z.ZodOptional<z.ZodObject<{
             profile: z.ZodOptional<z.ZodEnum<{

package/dist/types/defaults/skc-ui-skills.d.ts

@@ -0,0 +1,12 @@
+import type { Skill } from "../extensibility/skills";
+/**
+ * Bundled frontend UI/UX craft skills. These are NOT public SKC workflow skills.
+ * The four public workflows remain deep-interview, ralplan, ultragoal, and team.
+ *
+ * Sources and deliberate exclusions are documented in
+ * `skc/ui-skills/NOTICE.md`; regenerate with `scripts/build-ui-skill-bundle.ts`.
+ */
+export declare const BUNDLED_SKC_UI_SKILL_NAMES: readonly ["emil-design-eng", "animate", "review-animations", "improve-animations", "find-animation-opportunities", "pick-ui-library", "prototype", "mobile-native", "animation-vocabulary", "apple-design", "ask-sonner", "appllama-app-design-skill", "react-bits"];
+export type BundledSkcUiSkillName = (typeof BUNDLED_SKC_UI_SKILL_NAMES)[number];
+export declare function getEmbeddedSkcUiSkills(): Skill[];
+export declare function withEmbeddedSkcUiSkills(skills: Skill[]): Skill[];

package/dist/types/hooks/ui-skill-keywords.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Automatic frontend UI/UX skill routing.
+ *
+ * The bundled UI craft skills (see `defaults/skc-ui-skills.ts`) are compiled
+ * into the binary, so the agent can invoke them without any user install. This
+ * module decides WHEN: the native `UserPromptSubmit` hook matches the prompt
+ * against the patterns below and injects a directive naming the skill to load.
+ *
+ * Unlike the canonical workflow skills, UI skills have no `skc state` mode
+ * state. Detection here never seeds workflow state; it only advertises the
+ * skill for the current turn.
+ *
+ * Patterns cover English and Korean because prompts arrive in both.
+ */
+import type { BundledSkcUiSkillName } from "../defaults/skc-ui-skills";
+export interface UiSkillKeywordDefinition {
+    skill: BundledSkcUiSkillName;
+    /** Higher wins when several patterns match the same prompt. */
+    priority: number;
+    pattern: RegExp;
+}
+/** Base craft skill paired with any specialized web frontend match. */
+export declare const UI_SKILL_BASE: BundledSkcUiSkillName;
+/**
+ * Ordered specialized detectors. The first (highest priority) match selects the
+ * lead skill; `emil-design-eng` is added as the craft baseline for build and
+ * review work.
+ */
+export declare const UI_SKILL_KEYWORD_DEFINITIONS: readonly UiSkillKeywordDefinition[];
+export interface UiSkillKeywordMatch {
+    skill: BundledSkcUiSkillName;
+    keyword: string;
+    priority: number;
+}
+/**
+ * Detect frontend UI/UX intent. Returns matches ordered by priority, most
+ * specific first, with `emil-design-eng` appended as the craft baseline.
+ */
+export declare function detectUiSkillKeywords(text: string): UiSkillKeywordMatch[];
+/**
+ * Build the `UserPromptSubmit` directive that makes the agent load the matching
+ * bundled UI skill for this turn. Returns null when the prompt is not frontend
+ * UI/UX work.
+ */
+export declare function buildUiSkillActivationContext(text: string): string | null;
+/**
+ * Frontend skills SKC routes to but deliberately does NOT vendor.
+ *
+ * `transitions.dev` publishes an agent skill, but its terms license only the
+ * CLI and Refine tooling under MIT; the transition collection itself carries a
+ * separate clause that forbids repackaging or publishing the collection (or a
+ * substantial part of it). Compiling it into the SKC binary and shipping that
+ * to every user is exactly the prohibited redistribution, while installing it
+ * into your own project is explicitly allowed. So SKC routes to a user-owned
+ * install and never carries the content.
+ */
+export interface ExternalUiSkillDefinition {
+    skill: string;
+    priority: number;
+    pattern: RegExp;
+    /**
+     * Upstream's own non-interactive install. `-a universal` lands the skill in
+     * `<project>/.agents/skills/`, which SKC's agents provider loads. It is the
+     * agent that runs this through its normal bash tool, so the install stays a
+     * visible, permissioned tool call — never a silent fetch inside the hook.
+     */
+    installCommand: string;
+    source: string;
+}
+export declare const EXTERNAL_UI_SKILL_DEFINITIONS: readonly ExternalUiSkillDefinition[];
+export declare function detectExternalUiSkills(text: string): ExternalUiSkillDefinition[];
+/**
+ * Directive for frontend skills SKC routes to but does not vendor.
+ *
+ * Installed: load it. Missing: the agent runs upstream's own non-interactive
+ * install itself, so the user never types the command. The install runs through
+ * the agent's bash tool — visible and permissioned — rather than as a silent
+ * network fetch inside this hook.
+ */
+export declare function buildExternalUiSkillContext(input: {
+    cwd: string;
+    home: string;
+    text: string;
+}): Promise<string | null>;

package/dist/types/session-import/redact.d.ts

@@ -8,7 +8,7 @@
  */
 export declare const IMPORT_REDACTED_PLACEHOLDER = "[REDACTED]";
 /** Bumped when patterns change; persisted in import provenance. */
-export declare const IMPORT_SANITIZER_VERSION = 3;
+export declare const IMPORT_SANITIZER_VERSION = 5;
 export interface ImportRedactionResult {
     value: string;
     redacted: number;

package/dist/types/setup/external-ui-skills.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Install the frontend UI skills SKC routes to but cannot bundle.
+ *
+ * Most UI craft skills are compiled into the binary (see
+ * `defaults/skc-ui-skills.ts`). A few upstreams license their content for use
+ * but forbid redistributing the collection, so SKC must not carry them. For
+ * those, this installs upstream's own published payload into the project, where
+ * SKC's skill discovery picks it up like any other project skill.
+ *
+ * Target is `<project>/.agents/skills/<name>/`, which SKC's agents provider
+ * loads on the project walk-up.
+ */
+export type ExternalUiSkillStatus = "installed" | "already-present" | "failed" | "missing";
+export interface ExternalUiSkillResult {
+    skill: string;
+    source: string;
+    status: ExternalUiSkillStatus;
+    path: string;
+    detail?: string;
+}
+export interface ExternalUiSkillsReport {
+    projectDir: string;
+    installed: number;
+    alreadyPresent: number;
+    failed: number;
+    missing: number;
+    skills: ExternalUiSkillResult[];
+}
+export interface InstallExternalUiSkillsOptions {
+    cwd: string;
+    /** Report what would happen without running any installer. */
+    check?: boolean;
+    /** Reinstall even when the skill is already present. */
+    force?: boolean;
+}
+export declare function installExternalUiSkills(options: InstallExternalUiSkillsOptions): Promise<ExternalUiSkillsReport>;
+export declare function formatExternalUiSkillsReport(report: ExternalUiSkillsReport): string;

package/dist/types/skc-runtime/ultragoal-runtime.d.ts

@@ -264,7 +264,19 @@ export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
     reason: string;
     currentGoalObjective?: string;
 }): Promise<UltragoalNudgeOutcome>;
-export declare function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null): Promise<void>;
+export declare function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null, options?: {
+    lockHeld?: boolean;
+}): Promise<void>;
+/**
+ * The single exclusion that decides who owns an Ultragoal run.
+ *
+ * Establishing ownership is a read-decide-write sequence: a start reads the plan,
+ * checks the outgoing succession fence, then commits `active`. Every caller that
+ * decides ownership — source admission, succession offer, and successor
+ * publication — runs that decision inside this lock, keyed on the plan.
+ */
+export declare function withUltragoalPlanOwnership<T>(cwd: string, sessionId: string, fn: () => Promise<T>): Promise<T>;
+export declare function resolveUltragoalOwnershipSession(cwd: string, sessionId?: string | null): Promise<string>;
 export declare function nonEmptyString(value: unknown): string | null;
 export declare function stringArray(value: unknown): string[] | null;
 export declare function hashPipelineMetadata(metadata: Omit<UltragoalPipelineMetadata, "metadataHash">): string;

package/dist/types/skc-runtime/ultragoal-succession.d.ts

@@ -0,0 +1,251 @@
+import { type RepositoryBinding } from "./repository-binding";
+import { type UltragoalCommandResult, type UltragoalGoalStatus, type UltragoalPlan, type UltragoalSkcGoalMode } from "./ultragoal-runtime";
+export declare const ULTRAGOAL_SUCCESSION_OPERATION_SCHEMA: "skc.ultragoal_succession_operation.v1";
+export declare const ULTRAGOAL_SUCCESSION_OFFER_SCHEMA: "skc.ultragoal_succession_offer.v1";
+export declare const ULTRAGOAL_SUCCESSION_FENCE_SCHEMA: "skc.ultragoal_succession_fence.v1";
+export declare const ULTRAGOAL_SUCCESSION_ADOPTION_SCHEMA: "skc.ultragoal_succession_adoption.v1";
+export declare const ULTRAGOAL_SUCCESSION_CLAIM_SCHEMA: "skc.ultragoal_succession_claim.v1";
+export declare const SUCCESSION_ADOPTED_EVENT: "succession_adopted";
+export type UltragoalSuccessionErrorCode = "source_plan_missing" | "source_not_quiescent" | "invalid_selection" | "unsafe_target" | "authorization_required" | "divergent_operation" | "goal_handed_off" | "adoption_unpublished" | "publication_conflict" | "published_plan_missing" | "fence_missing" | "fence_mismatch" | "source_changed" | "offer_untrusted" | "offer_path_escape" | "target_mismatch" | "target_occupied" | "duplicate_adoption";
+export declare class UltragoalSuccessionError extends Error {
+    readonly code: UltragoalSuccessionErrorCode;
+    constructor(code: UltragoalSuccessionErrorCode, message: string);
+}
+export interface UltragoalSuccessionArtifactDigests {
+    briefSha256: string;
+    goalsSha256: string;
+    ledgerSha256: string;
+}
+export interface UltragoalSuccessionCarriedGoal {
+    sourceGoalId: string;
+    title: string;
+    /** The source objective, verbatim. Never a summary. */
+    objective: string;
+    /** Historical provenance only; never a receipt. */
+    sourceStatusAtOffer: UltragoalGoalStatus;
+    unresolvedObligations: string[];
+    /**
+     * Source dependency groups this goal belonged to, carried as an obligation
+     * with explicit id mapping. The group's *metadata* (batch hashes, receipts)
+     * is deliberately not carried — that would be inherited validation authority.
+     * What is carried is the requirement that these goals be validated together.
+     */
+    dependencyGroups: UltragoalSuccessionDependencyGroup[];
+}
+export type UltragoalSuccessionDependencyGroupKind = "validation-batch" | "review-blocker";
+export interface UltragoalSuccessionDependencyGroup {
+    kind: UltragoalSuccessionDependencyGroupKind;
+    groupId: string;
+    memberSourceGoalIds: string[];
+    /** For validation batches: the source goal that closed the batch. */
+    finalSourceGoalId?: string;
+}
+/**
+ * Per-selected-goal snapshot of exactly what was offered.
+ *
+ * Admission compares *this*, not whole-file equality. The fence deliberately
+ * leaves unselected goals schedulable, so ordinary source progress moves
+ * `goals.json`/`ledger.jsonl` bytes; requiring whole-file equality would
+ * permanently strand the selected work through drift that never touched it
+ * (issue #5353 review item 3). Whole-file digests remain recorded as provenance
+ * and any observed drift is written into the adoption record.
+ */
+export interface UltragoalSuccessionSelectionSnapshot {
+    /** The brief carries global constraints, so it must not change. */
+    briefSha256: string;
+    goals: Array<{
+        sourceGoalId: string;
+        recordSha256: string;
+        obligationsSha256: string;
+    }>;
+    snapshotSha256: string;
+}
+export interface UltragoalSuccessionOffer {
+    schema: typeof ULTRAGOAL_SUCCESSION_OFFER_SCHEMA;
+    operationId: string;
+    createdAt: string;
+    source: {
+        sessionId: string;
+        repository: RepositoryBinding;
+        /** Whole-file digests at offer time. Provenance; not the admission test. */
+        artifacts: UltragoalSuccessionArtifactDigests;
+        /** The authoritative admission test for "did the offered work change". */
+        selectionSnapshot: UltragoalSuccessionSelectionSnapshot;
+        skcGoalMode: UltragoalSkcGoalMode;
+    };
+    target: {
+        repository: RepositoryBinding;
+    };
+    selection: {
+        goalIds: string[];
+    };
+    carryover: {
+        /** The source brief, verbatim. */
+        brief: string;
+        goals: UltragoalSuccessionCarriedGoal[];
+    };
+    authorization: {
+        statement: string;
+        authorizedBy: string;
+    };
+    provenanceNotice: string;
+}
+export interface UltragoalSuccessionFence {
+    schema: typeof ULTRAGOAL_SUCCESSION_FENCE_SCHEMA;
+    operationId: string;
+    createdAt: string;
+    sourceSessionId: string;
+    sourceRepository: RepositoryBinding;
+    targetRepository: RepositoryBinding;
+    selectedGoalIds: string[];
+    sourceArtifacts: UltragoalSuccessionArtifactDigests;
+    offerPath: string;
+    offerSha256: string;
+}
+export interface UltragoalSuccessionGoalMapping {
+    sourceGoalId: string;
+    targetGoalId: string;
+}
+export interface UltragoalSuccessionAdoption {
+    schema: typeof ULTRAGOAL_SUCCESSION_ADOPTION_SCHEMA;
+    operationId: string;
+    status: "pending" | "published";
+    claimedAt: string;
+    publishedAt?: string;
+    targetSessionId: string;
+    targetRepository: RepositoryBinding;
+    source: {
+        sessionId: string;
+        repository: RepositoryBinding;
+        artifacts: UltragoalSuccessionArtifactDigests;
+        /** Whole-file digests observed at adoption; may differ from the offer. */
+        artifactsAtAdoption: UltragoalSuccessionArtifactDigests;
+        /** Whole-file drift on goals the offer did not select, recorded honestly. */
+        unselectedDrift: string[];
+        verifiedAt: string;
+    };
+    goalMap: UltragoalSuccessionGoalMapping[];
+    /**
+     * Content digest of the plan this operation is entitled to publish, recorded
+     * before publication. A pending replay may only proceed when the target plan
+     * is absent or matches this exactly; anything else is someone else's work.
+     */
+    expectedPlanDigest: string;
+    /** Pinned so the published plan is a deterministic function of the claim. */
+    plannedAt: string;
+    offerPath: string;
+    offerSha256: string;
+    fencePath: string;
+    claimPath: string;
+    authorization: {
+        statement: string;
+        authorizedBy: string;
+    };
+    provenanceNotice: string;
+}
+/**
+ * Repository-wide adoption claim.
+ *
+ * The session-scoped adoption record cannot be the exclusion primitive: two
+ * simultaneous sessions in one repository each create their own file and both
+ * win. This claim is a single O_EXCL file per operation for the whole
+ * repository, so exclusion is atomic rather than scan-then-write.
+ */
+export interface UltragoalSuccessionRepositoryClaim {
+    schema: typeof ULTRAGOAL_SUCCESSION_CLAIM_SCHEMA;
+    operationId: string;
+    targetSessionId: string;
+    targetWorktreeRoot: string;
+    targetCommonDir: string | null;
+    claimedAt: string;
+}
+export declare function ultragoalSuccessionDir(cwd: string, sessionId: string): string;
+export declare function ultragoalSuccessionFencePath(cwd: string, sessionId: string): string;
+export declare function ultragoalSuccessionAdoptionPath(cwd: string, sessionId: string): string;
+export declare function ultragoalSuccessionOfferPath(cwd: string, sessionId: string, operationId: string): string;
+/**
+ * Repository-wide (deliberately NOT session-scoped) adoption claim.
+ *
+ * Session directories cannot express "this repository has already adopted this
+ * operation", so the exclusion primitive lives beside them under the shared
+ * ultragoal root that `getUltragoalPaths` already uses for session-less state.
+ */
+export declare function ultragoalSuccessionClaimPath(cwd: string, operationId: string): string;
+/** Read the durable outgoing ownership fence for a source session, if any. */
+export declare function readUltragoalSuccessionFence(cwd: string, sessionId: string): Promise<UltragoalSuccessionFence | null>;
+/** Read the durable adoption claim for a target session, if any. */
+export declare function readUltragoalSuccessionAdoption(cwd: string, sessionId: string): Promise<UltragoalSuccessionAdoption | null>;
+/**
+ * Source admission guard: a goal that has been handed off to a successor run is
+ * no longer this run's to schedule or checkpoint.
+ *
+ * Goals outside the fenced selection stay fully schedulable — the fence defines
+ * one owner per goal, not a freeze of the whole source run.
+ */
+export declare function assertUltragoalGoalNotFenced(cwd: string, sessionId: string | null | undefined, goalId: string): Promise<void>;
+/**
+ * Target admission guard: an adoption that has not finished publishing does not
+ * yet own anything.
+ *
+ * Publication writes `goals.json` before it marks the claim published, so a
+ * crash leaves a *visible plan with an unpublished claim*. A visible plan is not
+ * admission evidence — the claim is. Without this, the target executes goals
+ * whose adoption was never completed, and the run's own completion receipts
+ * would rest on a transaction that never committed.
+ *
+ * Callers must invoke this before any mutation so a refusal leaves `goals.json`
+ * and `ledger.jsonl` untouched.
+ */
+export declare function assertUltragoalAdoptionPublished(cwd: string, sessionId: string | null | undefined): Promise<void>;
+export interface UltragoalSuccessionOfferInput {
+    cwd: string;
+    sessionId?: string | null;
+    targetRepositoryPath: string;
+    goalIds: readonly string[];
+    authorization: string;
+    authorizedBy: string;
+}
+export interface UltragoalSuccessionOfferResult {
+    operationId: string;
+    offerPath: string;
+    fencePath: string;
+    offer: UltragoalSuccessionOffer;
+    /** True when an identical prior operation was reconciled instead of re-recorded. */
+    reconciled: boolean;
+}
+/**
+ * Record an explicit successor offer and fence the selected goals off from the
+ * source run. Writes nothing to the source brief, goals or ledger.
+ */
+export declare function offerUltragoalSuccession(input: UltragoalSuccessionOfferInput): Promise<UltragoalSuccessionOfferResult>;
+export interface UltragoalSuccessionAdoptInput {
+    cwd: string;
+    sessionId?: string | null;
+    offerPath: string;
+    skcGoalMode?: UltragoalSkcGoalMode;
+}
+export interface UltragoalSuccessionAdoptResult {
+    operationId: string;
+    adoptionPath: string;
+    plan: UltragoalPlan;
+    goalMap: UltragoalSuccessionGoalMapping[];
+    reconciled: boolean;
+}
+/**
+ * Adopt an explicit successor offer into this repository/session.
+ *
+ * Fails closed on a forged or stale offer, a changed source, a missing source
+ * fence, an unnamed target, an occupied target, and any duplicate or divergent
+ * adoption anywhere in this repository. A retry reconciles the exact recorded
+ * operation or fails closed; it never resumes a different one.
+ */
+export declare function adoptUltragoalSuccession(input: UltragoalSuccessionAdoptInput): Promise<UltragoalSuccessionAdoptResult>;
+/**
+ * `skc ultragoal succession <offer|adopt|status>`.
+ *
+ * Kept out of `RECONCILE_COMMANDS` on purpose: the reconcile pass appends a
+ * `reconcile_failed` ledger row on failure, which would move the very source
+ * digests this feature records. The target's workflow state and HUD reconcile on
+ * the next ordinary `skc ultragoal status`.
+ */
+export declare function runUltragoalSuccessionCommand(args: readonly string[], cwd: string): Promise<UltragoalCommandResult>;

package/dist/types/skc-runtime/workflow-placeholder.d.ts

@@ -0,0 +1,6 @@
+/** Shared placeholder semantics for model-authored workflow content. */
+export declare const WORKFLOW_PLACEHOLDER_CORRECTION = "provide a specific, non-placeholder question or objective instead of empty, whitespace, unused, TODO, TBD, N/A, N-A, NA, none, placeholder, or stub";
+/** Exact, case-insensitive placeholder detection; meaningful sentences remain valid. */
+export declare function isWorkflowPlaceholderText(value: unknown): boolean;
+/** Detect a legacy formatted deep-interview ask whose visible body is a placeholder. */
+export declare function isLegacyDeepInterviewPlaceholder(value: unknown): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.5.11",
+	"version": "0.5.14",
 	"description": "Sayknow-CLI CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
@@ -54,12 +54,12 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@sayknow-cli/stats": "0.5.11",
-		"@sayknow-cli/agent-core": "0.5.11",
-		"@sayknow-cli/ai": "0.5.11",
-		"@sayknow-cli/natives": "0.5.11",
-		"@sayknow-cli/tui": "0.5.11",
-		"@sayknow-cli/utils": "0.5.11",
+		"@sayknow-cli/stats": "0.5.14",
+		"@sayknow-cli/agent-core": "0.5.14",
+		"@sayknow-cli/ai": "0.5.14",
+		"@sayknow-cli/natives": "0.5.14",
+		"@sayknow-cli/tui": "0.5.14",
+		"@sayknow-cli/utils": "0.5.14",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/setup-cli.ts

@@ -23,6 +23,7 @@ import {
 	getAutoImportOAuthCredentialSkips,
 	isAutoImportOAuthCredential,
 } from "../setup/credential-import";
+import { formatExternalUiSkillsReport, installExternalUiSkills } from "../setup/external-ui-skills";
 import {
 	formatHermesSetupResult,
 	type HermesSetupFlags,
@@ -46,7 +47,8 @@ export type SetupComponent =
 	| "hooks"
 	| "provider"
 	| "python"
-	| "stt";
+	| "stt"
+	| "ui-skills";
 
 export interface SetupCommandArgs {
 	component: SetupComponent;
@@ -290,6 +292,25 @@ export async function runSetupCommand(cmd: SetupCommandArgs): Promise<void> {
 		case "credentials":
 			await handleCredentialsSetup(cmd.flags);
 			break;
+		case "ui-skills":
+			await handleUiSkillsSetup(cmd.flags);
+			break;
+	}
+}
+
+async function handleUiSkillsSetup(flags: SetupCommandArgs["flags"]): Promise<void> {
+	const report = await installExternalUiSkills({
+		cwd: process.cwd(),
+		check: flags.check,
+		force: flags.force,
+	});
+	if (flags.json) {
+		process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+	} else {
+		process.stdout.write(`${formatExternalUiSkillsReport(report)}\n`);
+	}
+	if (report.failed > 0 || (flags.check && report.missing > 0)) {
+		process.exitCode = 1;
 	}
 }