owenloop 0.5.20 → 0.5.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -4,6 +4,20 @@ All notable changes to this project are documented here. The format is based on
4
4
  [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
5
5
  adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
6
6
 
7
+ ## [0.5.22](https://github.com/typicalday/owenloop/compare/v0.5.21...v0.5.22) (2026-08-22)
8
+
9
+
10
+ ### Features
11
+
12
+ * **cli:** set a published workflow's catalog visibility ([#289](https://github.com/typicalday/owenloop/issues/289)) ([4878a52](https://github.com/typicalday/owenloop/commit/4878a520e2e02cfed24dbcbd8a3da9d2195f1b0e))
13
+
14
+ ## [0.5.21](https://github.com/typicalday/owenloop/compare/v0.5.20...v0.5.21) (2026-08-22)
15
+
16
+
17
+ ### Bug Fixes
18
+
19
+ * **work:** resolve bundle-locked calls targets on workers ([#287](https://github.com/typicalday/owenloop/issues/287)) ([a2a6b47](https://github.com/typicalday/owenloop/commit/a2a6b47699ddc8b02f8f645ecc4a0ddd5269cf11))
20
+
7
21
  ## [0.5.20](https://github.com/typicalday/owenloop/compare/v0.5.19...v0.5.20) (2026-08-22)
8
22
 
9
23
 
package/dist/src/cli.js CHANGED
@@ -63,7 +63,7 @@ import { BundleError, digestBundle, inspectBundle, packBundle, unpackBundle } fr
63
63
  import { acquireInstallLock, ADD_JOURNAL_FILENAME, archivePathViolation, commitInstall, finalizeInstallCommit, githubShaUrl, githubTarballUrl, installFolder, parkOldNameDir, parseRepoSpec, readLockfile, recoverInterruptedInstall, releaseInstallLock, removeAddJournal, rmRecursiveForce, rollbackInstallCommit, RollbackFailedError, stageFiles, STAGING_DIRNAME, writeAddJournal, writeLockfile, } from "./add.js";
64
64
  import { BundleIngestorUnavailableError, collectWorkflowStoreGarbage, compareStoreText, globalStoreRoot, installWorkflowBundle, inspectCasDefs, loadCasDefs, PreCommitVerifierUnavailableError, parseWorkflowCoordinate, projectStoreRoot, createBundleIngestor, createPreCommitVerifier, recoverWorkflowStore, storeIndexPath, workflowStoreReplacementRecovery, workflowStoreStatePaths, } from "./store/index.js";
65
65
  import { recoverInterruptedWorkflowStoreGc } from "./store/gc-recovery.js";
66
- import { asAgentIdentities, asCreateWorkflowOk, capabilityPublishReportText, asCapabilityRerouteAdded, asCapabilityRerouteRemoved, asCapabilityReroutes, asCapabilityRouteAdded, asCapabilityRouteRemoved, asCapabilityRoutes, asInterfaceCatalogList, asInterfaceCatalogVersion, asCrewCreated, asCrewDeleted, asCrewMemberAdded, asCrewMemberRemoved, asCrews, asRoutingAlerts, asRunRouting, asWhoami, computeServerDiff, credentialBackend, createWorkflowError, credentialFilePath, credentialSlot, DEFAULT_HUB, externalCredentialCommand, hashDefForHub, hubBindingPath, keychainServiceFor, listStoredHubOrigins, normalizeOrigin, parseWorkflowList, pkcePair, randomState, readCredentialFile, readHubBinding, readStoredCredential, resolveEndpoint, resolveKeychain, writeCredentialFile, writeHubBinding, } from "./hub.js";
66
+ import { asAgentIdentities, asCreateWorkflowOk, capabilityPublishReportText, asCapabilityRerouteAdded, asCapabilityRerouteRemoved, asCapabilityReroutes, asCapabilityRouteAdded, asCapabilityRouteRemoved, asCapabilityRoutes, asInterfaceCatalogList, asInterfaceCatalogVersion, asWorkflowCatalogVisibility, asCrewCreated, asCrewDeleted, asCrewMemberAdded, asCrewMemberRemoved, asCrews, asRoutingAlerts, asRunRouting, asWhoami, computeServerDiff, credentialBackend, createWorkflowError, credentialFilePath, credentialSlot, DEFAULT_HUB, externalCredentialCommand, hashDefForHub, hubBindingPath, keychainServiceFor, listStoredHubOrigins, normalizeOrigin, parseWorkflowList, pkcePair, randomState, readCredentialFile, readHubBinding, readStoredCredential, resolveEndpoint, resolveKeychain, writeCredentialFile, writeHubBinding, } from "./hub.js";
67
67
  import { fetchCapabilityMappings, recordCapabilityMappings } from "./capability-mapping-client.js";
68
68
  import { MODIFIER_SEPARATOR } from "./capabilities.js";
69
69
  import { loadSettings, settingsPath as executionSettingsPath } from "../packages/work/src/settings/settings.js";
@@ -1245,6 +1245,7 @@ ${' '.repeat(41)}the instance has reached a terminal status.
1245
1245
  capability bind <capability> <crew> [--hub <url>] add a crew to a workflow capability on the hub org — a capability may bind many crews (admin; human credential)
1246
1246
  capability unbind <capability> <crew> [--hub <url>] remove one (capability, crew) route
1247
1247
  capability list [--hub <url>] list the hub org's capability routes
1248
+ catalog visibility <name> visible|hidden [--hub <url>]
1248
1249
  interface register <name> <version> --signature <file> [--hub <url>]
1249
1250
  interface get <name> <version> [--hub <url>]
1250
1251
  interface list [--hub <url>]
@@ -1364,6 +1365,7 @@ export const COMMAND_OPTIONS = new Map([
1364
1365
  ['instance', cmdOpts('hub')],
1365
1366
  ['agent', cmdOpts('crews', 'hub', 'scopes', 'shift')],
1366
1367
  ['capability', cmdOpts('hub')],
1368
+ ['catalog', cmdOpts('hub')],
1367
1369
  ['interface', cmdOpts('hub', 'signature')],
1368
1370
  // Per-TOP-LEVEL-command allowlist, not per-subcommand: `--position` on
1369
1371
  // `routing alerts` is meaningless but accepted and ignored, exactly as
@@ -6255,6 +6257,76 @@ async function dispatchInterface(io, args) {
6255
6257
  throw e;
6256
6258
  }
6257
6259
  }
6260
+ /**
6261
+ * Set whether one published workflow definition appears in catalog discovery.
6262
+ * The hub remains the source of truth for opaque definition-name semantics and
6263
+ * returned state; this command only validates its small argv shape.
6264
+ */
6265
+ async function dispatchCatalog(io, args) {
6266
+ const USAGE_FORM = 'usage: owenloop catalog visibility <name> visible|hidden [--hub <url>]';
6267
+ if (args.positionals[1] !== 'visibility') {
6268
+ throw new CliError('unknown catalog subcommand ' + JSON.stringify(args.positionals[1] ?? '') + ' — ' + USAGE_FORM);
6269
+ }
6270
+ const name = args.positionals[2];
6271
+ if (name === undefined || name === '') {
6272
+ throw new CliError('missing required argument: <name> (' + USAGE_FORM + ')');
6273
+ }
6274
+ const state = args.positionals[3];
6275
+ if (state === undefined || state === '') {
6276
+ throw new CliError('missing required argument: visible|hidden (' + USAGE_FORM + ')');
6277
+ }
6278
+ if (args.positionals[4] !== undefined) {
6279
+ throw new CliError('too many positional arguments — ' + USAGE_FORM);
6280
+ }
6281
+ if (state !== 'visible' && state !== 'hidden') {
6282
+ throw new CliError('visibility state must be visible or hidden — ' + USAGE_FORM);
6283
+ }
6284
+ const visible = state === 'visible';
6285
+ const origin = resolveAgentHub(io, args, 'set workflow catalog visibility on');
6286
+ const slot = { principal: 'human' };
6287
+ const credential = readCredential(io, origin, slot);
6288
+ if (credential === null) {
6289
+ throw new CliError('no human credential for ' + origin + ' — run: owenloop login --hub ' + origin, { exitCode: 3 });
6290
+ }
6291
+ try {
6292
+ const { res } = await authedPost(io, origin, slot, credential, '/api/set_workflow_catalog_visibility', { name, visible });
6293
+ if (res.status === 401) {
6294
+ throw new CliError('credential rejected by the hub — run `owenloop login`');
6295
+ }
6296
+ if (!res.ok) {
6297
+ throw new CliError((await hubRequestMessage(res)) ?? ('hub ' + origin + ' rejected the request (HTTP ' + res.status + ')'));
6298
+ }
6299
+ let body;
6300
+ try {
6301
+ body = (await res.json());
6302
+ }
6303
+ catch {
6304
+ throw new CliError('set_workflow_catalog_visibility: malformed success response — body is not valid JSON');
6305
+ }
6306
+ let result;
6307
+ try {
6308
+ result = asWorkflowCatalogVisibility(body);
6309
+ }
6310
+ catch (e) {
6311
+ throw new CliError(e.message);
6312
+ }
6313
+ print(io, {
6314
+ ok: true,
6315
+ hub: origin,
6316
+ name: result.name,
6317
+ catalogVisible: result.catalogVisible,
6318
+ previousCatalogVisible: result.previousCatalogVisible,
6319
+ unchanged: result.unchanged,
6320
+ });
6321
+ return 0;
6322
+ }
6323
+ catch (e) {
6324
+ if (e instanceof CliError && /run `owenloop login`/.test(e.message)) {
6325
+ throw new CliError(e.message + ' — run: owenloop login --hub ' + origin, { exitCode: 3 });
6326
+ }
6327
+ throw e;
6328
+ }
6329
+ }
6258
6330
  /**
6259
6331
  * `owenloop capability bind|unbind|list` — manage the hub org's **capability routes**, the
6260
6332
  * admin-owned table mapping a workflow-def `capabilities:` entry to a crew.
@@ -8476,7 +8548,7 @@ async function runDoctor(io, origin) {
8476
8548
  * the async path, so every existing command and test keeps working exactly as
8477
8549
  * before.
8478
8550
  */
8479
- export const ASYNC_COMMANDS = new Set(['add', 'login', 'logout', 'connect', 'publish', 'trust', 'push', 'install', 'start', 'pending-gates', 'cancel', 'provide', 'reject', 'retry', 'instance', 'agent', 'capability', 'interface', 'routing', 'crew', 'roster', 'setup', 'doctor', 'enrollments', 'mcp', 'shift']);
8551
+ export const ASYNC_COMMANDS = new Set(['add', 'login', 'logout', 'connect', 'publish', 'trust', 'push', 'install', 'start', 'pending-gates', 'cancel', 'provide', 'reject', 'retry', 'instance', 'agent', 'capability', 'catalog', 'interface', 'routing', 'crew', 'roster', 'setup', 'doctor', 'enrollments', 'mcp', 'shift']);
8480
8552
  export async function mainAsync(argv, io = defaultIO()) {
8481
8553
  // Delegate execution-side and shift argv tails before root parsing. Their
8482
8554
  // roles own their option grammars, including repeated/value forms that the
@@ -8550,6 +8622,8 @@ export async function mainAsync(argv, io = defaultIO()) {
8550
8622
  return await dispatchAgent(io, args);
8551
8623
  case 'capability':
8552
8624
  return await dispatchCapability(io, args);
8625
+ case 'catalog':
8626
+ return await dispatchCatalog(io, args);
8553
8627
  case 'interface':
8554
8628
  return await dispatchInterface(io, args);
8555
8629
  case 'routing':
package/dist/src/hub.d.ts CHANGED
@@ -878,6 +878,15 @@ export interface InterfaceCatalogVersionWire extends InterfaceCatalogRowWire {
878
878
  export declare function asInterfaceCatalogVersion(body: unknown, endpoint: 'register_interface' | 'interfaces'): InterfaceCatalogVersionWire;
879
879
  /** Narrow `GET /api/interfaces`, preserving the hub's opaque row order. */
880
880
  export declare function asInterfaceCatalogList(body: unknown): InterfaceCatalogRowWire[];
881
+ /** The whitelisted success fields from set_workflow_catalog_visibility. */
882
+ export interface WorkflowCatalogVisibilityWire {
883
+ name: string;
884
+ catalogVisible: boolean;
885
+ previousCatalogVisible: boolean;
886
+ unchanged: boolean;
887
+ }
888
+ /** Narrow the visibility setter response without preserving its text or unknown fields. */
889
+ export declare function asWorkflowCatalogVisibility(body: unknown): WorkflowCatalogVisibilityWire;
881
890
  /**
882
891
  * One **routing alert** as the hub reports it — an org-scoped record that the
883
892
  * hub made a routing decision an operator needs to know about.
package/dist/src/hub.js CHANGED
@@ -1329,6 +1329,32 @@ export function asInterfaceCatalogList(body) {
1329
1329
  }
1330
1330
  return body.interfaces.map((entry, index) => asInterfaceCatalogRow(entry, prefix, `interfaces[${index}]`));
1331
1331
  }
1332
+ /** Narrow the visibility setter response without preserving its text or unknown fields. */
1333
+ export function asWorkflowCatalogVisibility(body) {
1334
+ const prefix = 'set_workflow_catalog_visibility: malformed success response';
1335
+ if (typeof body !== 'object' || body === null) {
1336
+ throw new Error(prefix + ' — response is not an object');
1337
+ }
1338
+ const value = body;
1339
+ if (typeof value.name !== 'string' || value.name === '') {
1340
+ throw new Error(prefix + ' — response missing non-empty string name');
1341
+ }
1342
+ if (typeof value.catalogVisible !== 'boolean') {
1343
+ throw new Error(prefix + ' — response missing boolean catalogVisible');
1344
+ }
1345
+ if (typeof value.previousCatalogVisible !== 'boolean') {
1346
+ throw new Error(prefix + ' — response missing boolean previousCatalogVisible');
1347
+ }
1348
+ if (value.unchanged !== undefined && typeof value.unchanged !== 'boolean') {
1349
+ throw new Error(prefix + ' — response unchanged must be boolean when present');
1350
+ }
1351
+ return {
1352
+ name: value.name,
1353
+ catalogVisible: value.catalogVisible,
1354
+ previousCatalogVisible: value.previousCatalogVisible,
1355
+ unchanged: value.unchanged ?? false,
1356
+ };
1357
+ }
1332
1358
  /**
1333
1359
  * Validate the eight `RoutingAlertWire` fields on one row. `prefix` is the
1334
1360
  * endpoint-qualified lead-in the caller wants (e.g.
@@ -7,13 +7,13 @@
7
7
  * requested order digest. `lookup` then reads only the verified definition held
8
8
  * in the in-memory cache populated by that prime.
9
9
  */
10
- import { dirname, join } from 'node:path';
10
+ import { join } from 'node:path';
11
11
  import { readFileSync } from 'node:fs';
12
- import { parseManifestBytes } from "../bundle/manifest.js";
12
+ import { isVersionedReference, parseManifestBytes } from "../bundle/manifest.js";
13
13
  import { defInstructionDigest } from "../order-resolver.js";
14
- import { finalizeDefs, loadDefFile } from "../defs.js";
14
+ import { digestScopedCallsTargetKey, finalizeDefs, loadDefFile } from "../defs.js";
15
15
  import { readWorkflowStoreIndex } from "./index-file.js";
16
- import { StoreIntegrityError, compareStoreText, defDigest, objectDirForDigest, } from "./types.js";
16
+ import { StoreIntegrityError, compareStoreText, defDigest, objectDirForDigest, parseWorkflowCoordinate, } from "./types.js";
17
17
  import { coordinateDigestRead, projectStoreRoot, probeObjectDir, probeStoreRoot, storeIndexPath, } from "./resolve.js";
18
18
  export class StoreInstructionSourceError extends Error {
19
19
  name = 'StoreInstructionSourceError';
@@ -60,45 +60,191 @@ function asDefDigest(raw) {
60
60
  return undefined;
61
61
  }
62
62
  }
63
+ function errorText(error) {
64
+ return error instanceof Error ? error.message : String(error);
65
+ }
66
+ /**
67
+ * Read every workflow from one exact, already-addressed object. This is shared
68
+ * by a requested parent and its lock-pinned dependencies so child bytes get
69
+ * precisely the same installed-object verification before they are parsed.
70
+ */
71
+ async function loadVerifiedObject(root, bundleDigest, level, verifier) {
72
+ return coordinateDigestRead(root, bundleDigest, async () => {
73
+ const objectPath = await verifiedCandidateObject(root, bundleDigest, level, verifier);
74
+ try {
75
+ const manifest = parseManifestBytes(readFileSync(join(objectPath, 'bundle.yaml')));
76
+ const defs = new Map();
77
+ for (const [workflowName, workflowPath] of Object.entries(manifest.workflows)) {
78
+ const def = loadDefFile(join(objectPath, workflowPath));
79
+ if (def.name !== workflowName) {
80
+ throw new StoreIntegrityError('object-corrupt', bundleDigest, `workflow '${workflowPath}' has definition name '${def.name}', expected '${workflowName}'`);
81
+ }
82
+ // CAS provenance is part of calls: resolution, not the instruction
83
+ // projection. defInstructionDigest deliberately excludes it.
84
+ def.bundlePackage = manifest.package.name;
85
+ def.bundleDigest = bundleDigest;
86
+ def.bundleLock = { ...manifest.lock };
87
+ defs.set(def.name, def);
88
+ }
89
+ return { bundleDigest, objectPath, root, level, manifest, defs };
90
+ }
91
+ catch (error) {
92
+ if (error instanceof StoreIntegrityError)
93
+ throw error;
94
+ throw new StoreIntegrityError('object-corrupt', bundleDigest, errorText(error));
95
+ }
96
+ });
97
+ }
63
98
  export function createStoreInstructionSource(args) {
64
99
  const projectRoot = args.projectRoot === undefined ? undefined : projectStoreRoot(args.projectRoot);
65
100
  const globalRoot = projectStoreRoot(args.globalRoot);
66
101
  const cache = new Map();
67
102
  const inFlight = new Map();
68
- const loadCandidate = async (requestedDigest, bundleDigest, root, level) => coordinateDigestRead(root, bundleDigest, async () => {
69
- const objectPath = await verifiedCandidateObject(root, bundleDigest, level, args.verifier);
70
- const manifest = parseManifestBytes(readFileSync(join(objectPath, 'bundle.yaml')));
71
- const loaded = new Map();
72
- for (const [workflowName, workflowPath] of Object.entries(manifest.workflows)) {
73
- const def = loadDefFile(join(objectPath, workflowPath));
74
- if (def.name !== workflowName) {
75
- throw new StoreIntegrityError('object-corrupt', bundleDigest, `workflow '${workflowPath}' has definition name '${def.name}', expected '${workflowName}'`);
103
+ const configuredRoots = () => {
104
+ const roots = [];
105
+ if (projectRoot !== undefined)
106
+ roots.push({ root: projectRoot, level: 'project' });
107
+ roots.push({ root: globalRoot, level: 'global' });
108
+ return roots.filter((candidate, index) => roots.findIndex((other) => other.root === candidate.root) === index);
109
+ };
110
+ /**
111
+ * Build the private, verified closure required to validate exact locked
112
+ * calls. It intentionally walks only digests named by the parent chain, not
113
+ * the whole store: unrelated indexed corruption must not poison this order.
114
+ */
115
+ const loadCandidate = async (requestedDigest, bundleDigest, root, level) => {
116
+ const parent = await loadVerifiedObject(root, bundleDigest, level, args.verifier);
117
+ const validation = new Map(parent.defs);
118
+ const support = new Map();
119
+ const loadedByRootAndDigest = new Map();
120
+ const registeredDependencies = new Set();
121
+ const walked = new Set();
122
+ const keyFor = (object) => `${object.root}:${object.bundleDigest}`;
123
+ const remember = (object) => {
124
+ support.set(keyFor(object), object);
125
+ };
126
+ const registerDependencyDefinitions = (object) => {
127
+ const key = keyFor(object);
128
+ if (registeredDependencies.has(key))
129
+ return;
130
+ registeredDependencies.add(key);
131
+ for (const [workflowName, def] of object.defs) {
132
+ validation.set(digestScopedCallsTargetKey(object.bundleDigest, workflowName), def);
76
133
  }
77
- loaded.set(def.name, def);
78
- }
79
- const finalized = finalizeDefs(loaded);
134
+ };
135
+ remember(parent);
136
+ loadedByRootAndDigest.set(keyFor(parent), parent);
137
+ const dependencyRoots = (from) => {
138
+ const roots = [{ root: from.root, level: from.level }, ...configuredRoots()];
139
+ return roots.filter((candidate, index) => roots.findIndex((other) => other.root === candidate.root) === index);
140
+ };
141
+ const loadAt = async (childDigest, candidate) => {
142
+ const key = `${candidate.root}:${childDigest}`;
143
+ const existing = loadedByRootAndDigest.get(key);
144
+ if (existing !== undefined)
145
+ return existing;
146
+ const loaded = await loadVerifiedObject(candidate.root, childDigest, candidate.level, args.verifier);
147
+ loadedByRootAndDigest.set(key, loaded);
148
+ remember(loaded);
149
+ return loaded;
150
+ };
151
+ const selectLockedTarget = (target, childDigest, child) => {
152
+ let coordinate;
153
+ try {
154
+ coordinate = parseWorkflowCoordinate(target);
155
+ }
156
+ catch (error) {
157
+ throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' has an invalid coordinate: ${errorText(error)}`);
158
+ }
159
+ if (coordinate.name !== child.manifest.package.name
160
+ || coordinate.version !== child.manifest.package.version) {
161
+ throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' does not match child manifest package '${child.manifest.package.name}@${child.manifest.package.version}'`);
162
+ }
163
+ const workflowName = child.manifest.default
164
+ ?? (child.defs.size === 1 ? child.defs.keys().next().value : undefined);
165
+ if (workflowName === undefined) {
166
+ throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' digest ${childDigest} exports multiple workflows and has no default`);
167
+ }
168
+ const selected = child.defs.get(workflowName);
169
+ if (selected === undefined) {
170
+ throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' selects missing child workflow '${workflowName}'`);
171
+ }
172
+ return selected;
173
+ };
174
+ const walkObject = async (object) => {
175
+ const objectKey = keyFor(object);
176
+ if (walked.has(objectKey))
177
+ return;
178
+ walked.add(objectKey);
179
+ for (const def of object.defs.values()) {
180
+ for (const step of def.steps) {
181
+ if (step.calls === undefined || !isVersionedReference(step.calls))
182
+ continue;
183
+ const target = step.calls;
184
+ if (!Object.prototype.hasOwnProperty.call(object.manifest.lock, target)) {
185
+ throw new StoreIntegrityError('object-corrupt', object.bundleDigest, `locked calls target '${target}' has no entry in parent bundle ${object.bundleDigest} manifest lock`);
186
+ }
187
+ const childDigest = defDigest(object.manifest.lock[target]);
188
+ let child;
189
+ for (const candidate of dependencyRoots(object)) {
190
+ try {
191
+ child = await loadAt(childDigest, candidate);
192
+ break;
193
+ }
194
+ catch (error) {
195
+ if (error instanceof StoreIntegrityError && error.code === 'object-missing')
196
+ continue;
197
+ const verified = error instanceof StoreIntegrityError
198
+ && error.message.includes('object failed verification');
199
+ throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' digest ${childDigest} at ${candidate.level}-level root '${candidate.root}' ` +
200
+ `${verified ? 'failed installed-object verification' : 'could not load verified child'}: ${errorText(error)}`);
201
+ }
202
+ }
203
+ if (child === undefined) {
204
+ throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' digest ${childDigest} is absent from every configured workflow store root`);
205
+ }
206
+ const selected = selectLockedTarget(target, childDigest, child);
207
+ // An alias is the only qualified path a parent calls: edge may take.
208
+ // All child workflows also retain an internal digest-scoped key so their
209
+ // bare sibling calls validate in the bundle that authored them.
210
+ if (child !== parent)
211
+ registerDependencyDefinitions(child);
212
+ validation.set(digestScopedCallsTargetKey(childDigest, target), selected);
213
+ await walkObject(child);
214
+ }
215
+ }
216
+ };
217
+ await walkObject(parent);
218
+ const finalized = finalizeDefs(validation);
219
+ const parentDefinitions = [...parent.defs.keys()].map((name) => finalized.get(name));
220
+ const cachedSupport = [...support.values()];
80
221
  // Hub-backed orders use the immutable bundle digest as their execution
81
- // identity. Keep every workflow from that exact verified object in the
82
- // cache; the later step lookup selects a unique definition and refuses an
83
- // ambiguous step name instead of choosing one by manifest order.
222
+ // identity. Dependencies are validation-only: never cache or publish them
223
+ // under the parent digest, even when a child step name is globally unique.
84
224
  if (requestedDigest === bundleDigest) {
85
- cache.set(requestedDigest, [...finalized.values()].map((def) => ({
225
+ cache.set(requestedDigest, parentDefinitions.map((def) => ({
86
226
  def,
87
227
  bundleDigest,
88
- objectPath,
228
+ objectPath: parent.objectPath,
229
+ support: cachedSupport,
89
230
  })));
90
231
  return true;
91
232
  }
92
233
  // Plain-YAML/local-engine orders retain the per-definition projection
93
234
  // digest path for backwards compatibility.
94
- for (const def of finalized.values()) {
235
+ for (const def of parentDefinitions) {
95
236
  if (defInstructionDigest(def) === requestedDigest) {
96
- cache.set(requestedDigest, [{ def, bundleDigest, objectPath }]);
237
+ cache.set(requestedDigest, [{
238
+ def,
239
+ bundleDigest,
240
+ objectPath: parent.objectPath,
241
+ support: cachedSupport,
242
+ }]);
97
243
  return true;
98
244
  }
99
245
  }
100
246
  return false;
101
- });
247
+ };
102
248
  const candidateFailureForRefusal = (error) => error instanceof StoreIntegrityError && error.code === 'object-missing' ? undefined : error;
103
249
  const scanTier = async (requestedDigest, bundleDigests, root, level) => {
104
250
  let firstFailure;
@@ -118,11 +264,12 @@ export function createStoreInstructionSource(args) {
118
264
  };
119
265
  const evictObject = (bundleDigest, objectPath) => {
120
266
  for (const [instructionDigest, cached] of cache) {
121
- const retained = cached.filter((candidate) => candidate.bundleDigest !== bundleDigest || candidate.objectPath !== objectPath);
122
- if (retained.length === 0)
267
+ // A cached entry is valid only while EVERY object that supported its
268
+ // locked-edge closure is valid. Never leave a parent usable after a
269
+ // supporting child changes or disappears.
270
+ if (cached.some((candidate) => candidate.support.some((support) => support.bundleDigest === bundleDigest && support.objectPath === objectPath))) {
123
271
  cache.delete(instructionDigest);
124
- else if (retained.length !== cached.length)
125
- cache.set(instructionDigest, retained);
272
+ }
126
273
  }
127
274
  };
128
275
  const verifyCached = async (requestedDigest) => {
@@ -131,23 +278,24 @@ export function createStoreInstructionSource(args) {
131
278
  return false;
132
279
  const verified = new Set();
133
280
  for (const candidate of cached) {
134
- const key = `${candidate.bundleDigest}:${candidate.objectPath}`;
135
- if (verified.has(key))
136
- continue;
137
- verified.add(key);
138
- const root = dirname(dirname(dirname(candidate.objectPath)));
139
- try {
140
- await coordinateDigestRead(root, candidate.bundleDigest, async () => {
141
- const verify = args.verifier.verifyInstalledObjectAfterCoordination ?? args.verifier.verifyInstalledObject;
142
- await verify.call(args.verifier, {
143
- objectDir: candidate.objectPath,
144
- digest: candidate.bundleDigest,
281
+ for (const support of candidate.support) {
282
+ const key = `${support.root}:${support.bundleDigest}`;
283
+ if (verified.has(key))
284
+ continue;
285
+ verified.add(key);
286
+ try {
287
+ await coordinateDigestRead(support.root, support.bundleDigest, async () => {
288
+ const verify = args.verifier.verifyInstalledObjectAfterCoordination ?? args.verifier.verifyInstalledObject;
289
+ await verify.call(args.verifier, {
290
+ objectDir: support.objectPath,
291
+ digest: support.bundleDigest,
292
+ });
145
293
  });
146
- });
147
- }
148
- catch (error) {
149
- evictObject(candidate.bundleDigest, candidate.objectPath);
150
- throw error;
294
+ }
295
+ catch (error) {
296
+ evictObject(support.bundleDigest, support.objectPath);
297
+ throw error;
298
+ }
151
299
  }
152
300
  }
153
301
  return true;
package/docs/bundles.md CHANGED
@@ -75,7 +75,7 @@ The following rules apply:
75
75
  - `runtime` is optional. When present, `runtime` is a closed mapping that contains `minVersion`, `features`, or both; `runtime: {}` is invalid. Runtime requirements are described in [Runtime compatibility](#runtime-compatibility).
76
76
  - `workflows` is a non-empty map from workflow names to archive-relative YAML paths. Each workflow name matches `/^[a-z][a-z0-9-]*$/`. Each path must pass the canonical bundle path safety policy, and two workflow names may not point to the same path.
77
77
  - A workflow file's `name:` must equal the workflow map key. For example, `workflows.delivery` must point to a file containing `name: delivery`.
78
- - An installed workflow is addressable from `calls:` by the qualified name `<package>/<workflow>`. A bare `calls: <workflow>` inside a CAS-installed bundle is resolved to a sibling from that same bundle; it does not search unrelated bundles for a same-named workflow. An exact versioned `calls: namespace/name@version` resolves through the verified store-index coordinate to the bundle's selected default workflow, then the engine checks the matching `lock` digest before creating the child.
78
+ - An installed workflow is addressable from `calls:` by the qualified name `<package>/<workflow>`. A bare `calls: <workflow>` inside a CAS-installed bundle is resolved to a sibling from that same bundle; it does not search unrelated bundles for a same-named workflow. For local-engine coordinate discovery, an exact versioned `calls: namespace/name@version` resolves through the verified store-index coordinate to the bundle's selected default workflow, then the engine checks the matching `lock` digest before creating the child. A worker validates the same edge differently: it follows only the verified parent manifest's pinned lock digest to a locally verified CAS object and never uses coordinator-supplied child definition bytes.
79
79
  - `default` is optional. When present, `default` must be one of the workflow map keys. When absent, a single-workflow package has that one workflow as its implicit default. A package with two or more workflows has no implicit default: the versioned coordinate is not registered as a callable target, while explicit `<package>/<workflow>` targets remain available.
80
80
  - `platforms` is a duplicate-free list of portable selector strings. The list is advisory; platform policy is outside the package parser.
81
81
  - `integrity.algorithm` is exactly `sha256`.
package/docs/cli.md CHANGED
@@ -81,6 +81,7 @@ is independent of the `SEARCH INCOMPLETE` bounds notice.
81
81
  | `capability bind <capability> <crew> [--hub <url>]` | add a crew to a workflow capability on the hub org — a capability may route to many crews (admin; human credential) — see [Capability routes](#capability-routes) |
82
82
  | `capability unbind <capability> <crew> [--hub <url>]` | remove one `(capability, crew)` route — see [Capability routes](#capability-routes) |
83
83
  | `capability list [--hub <url>]` | list the hub org's capability routes — see [Capability routes](#capability-routes) |
84
+ | `catalog visibility <name> visible\|hidden [--hub <url>]` | set whether one published workflow definition appears in catalog discovery (admin; human credential) — see [Workflow catalog visibility](#workflow-catalog-visibility) |
84
85
  | `interface register <name> <version> --signature <file> [--hub <url>]` | register one immutable hub interface signature (admin; human credential) — see [Interface catalog](#interface-catalog) |
85
86
  | `interface get <name> <version> [--hub <url>]` | get one exact interface signature from the hub — see [Interface catalog](#interface-catalog) |
86
87
  | `interface list [--hub <url>]` | list every registered interface coordinate — see [Interface catalog](#interface-catalog) |
@@ -2396,6 +2397,48 @@ needs a translation step.
2396
2397
  | `2` | the hub couldn't be resolved (no `--hub` and not exactly one stored hub) |
2397
2398
  | `3` | the human credential is missing or irrecoverable — the error names the remedy `owenloop login --hub <origin>` |
2398
2399
 
2400
+ ## Workflow catalog visibility
2401
+
2402
+ Use `owenloop catalog visibility <name> visible|hidden [--hub <url>]` to set
2403
+ whether one published workflow definition is shown in catalog discovery. The
2404
+ `catalog` namespace names the discovery surface directly; `defs` is local
2405
+ definition discovery and `workflow` would be ambiguous with workflow-instance
2406
+ coordinates.
2407
+
2408
+ The CLI sends `POST /api/set_workflow_catalog_visibility` with
2409
+ `{ "name": "<name>", "visible": true }` for `visible` and the same body with
2410
+ `false` for `hidden`. It accepts only those two state words and only requires
2411
+ that `<name>` is non-empty; definition-name syntax and existence remain hub
2412
+ decisions.
2413
+
2414
+ This changes catalog discovery only. It does not change exact-name reads,
2415
+ starts, call resolution, authorization, or existing instances. Each invocation
2416
+ sets one definition: it does not read state, list/filter definitions, or accept
2417
+ bulk or glob inputs.
2418
+
2419
+ The command resolves `--hub` first; without it, exactly one enumerable stored
2420
+ hub is required. It uses only the human/admin credential, and supports
2421
+ `OWENLOOP_CREDENTIAL_COMMAND` because it writes no local credential. Successful
2422
+ stdout is exactly one JSON document:
2423
+
2424
+ `{ "ok": true, "hub": "<origin>", "name": "<server name>", "catalogVisible": false, "previousCatalogVisible": true, "unchanged": false }`
2425
+
2426
+ The server-echoed fields are authoritative. `unchanged: false` means this call
2427
+ changed visibility; `unchanged: true` means it was already in the requested
2428
+ state. Both are successful exit-0 results. The hub's `text` field and unknown
2429
+ response fields are never printed.
2430
+
2431
+ An unknown definition surfaces the hub's non-empty message unchanged (for
2432
+ example, its `DefNotFoundError` message), with no raw error code or replacement
2433
+ body. Malformed successful responses leave stdout empty.
2434
+
2435
+ | code | meaning |
2436
+ |---|---|
2437
+ | `0` | visibility was set, including an idempotent repeat |
2438
+ | `1` | usage, runtime, hub, or malformed-response error |
2439
+ | `2` | the hub could not be resolved |
2440
+ | `3` | the human credential is missing or irrecoverable; stderr names `owenloop login --hub <origin>` |
2441
+
2399
2442
  ## Interface catalog
2400
2443
 
2401
2444
  The hub's interface catalog is an append-only registry of exact opaque
package/docs/design.md CHANGED
@@ -1875,10 +1875,21 @@ operation required by `OrderResolver`:
1875
1875
  is loaded. A project object that exists but is corrupt is an integrity
1876
1876
  refusal; it is not hidden by a valid global copy.
1877
1877
  3. The source reads the verified object's `bundle.yaml`, loads every workflow
1878
- path listed in the `workflows` map, finalizes all definitions together, and
1879
- computes each instruction projection digest. The source caches the matching
1880
- definition when one projection digest equals the order's `defDigest`.
1881
- 4. `lookup` then serves the cached step's authored body and command bytes. A
1878
+ path listed in the `workflows` map, and attaches its package, digest, and
1879
+ copied manifest lock as CAS provenance. For every exact versioned
1880
+ `calls:` edge, it follows only that verified manifest's lock digest,
1881
+ verifies the exact child object with the same installed-object verifier,
1882
+ resolves the child's explicit default (or its sole workflow), and repeats
1883
+ recursively. It strictly finalizes the combined private map, so child
1884
+ inputs, output shape, and cross-bundle cycles remain executable-time
1885
+ validations rather than deferred assumptions.
1886
+ 4. The cache exposes only definitions originating in the requested object; a
1887
+ dependency is never addressable through its parent's digest. Each cache entry
1888
+ records every verified supporting object, and a later `prime` re-verifies
1889
+ that entire support set, evicting every dependent cached parent on a failure.
1890
+ The source then computes each requested-object instruction projection digest
1891
+ and caches the matching definition when one equals the order's `defDigest`.
1892
+ 5. `lookup` then serves the cached step's authored body and command bytes. A
1882
1893
  cache miss is `unknown-digest`; a known digest with no matching step is
1883
1894
  `unknown-step`.
1884
1895
 
package/docs/embedding.md CHANGED
@@ -137,9 +137,13 @@ const instructions = resolver.resolveOrder(order); // synchronous cache lookup
137
137
 
138
138
  `prime` returns `resolved` or `unknown-digest`; an integrity failure is a
139
139
  separate refusal. The source enumerates indexed bundle objects, verifies each
140
- candidate on read, loads every workflow path listed by its `bundle.yaml`, and
141
- matches each finalized definition's instruction projection digest to
142
- `order.defDigest`. The order's digest is the
140
+ candidate on read, and for an exact versioned `calls:` edge follows only the
141
+ digest in that verified parent's manifest lock. Each pinned child is verified
142
+ before its workflow bytes are read; the combined closure is finalized strictly,
143
+ but only definitions from the requested object enter the instruction cache.
144
+ Later primes re-verify every object supporting that closure. The source matches
145
+ each requested definition's instruction projection digest to `order.defDigest`.
146
+ The order's digest is the
143
147
  only instruction key supplied by the transport; the source never accepts
144
148
  prompt or command text from the packet. `createEngine` keeps its default
145
149
  loaded-definition emitter, because the store source's `digestOf` is deliberately
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "owenloop",
3
- "version": "0.5.20",
3
+ "version": "0.5.22",
4
4
  "description": "Deterministic rails for agentic workflows. Declare steps and dependencies; the engine guarantees order, redoes what changes invalidate, and stops what keeps failing — instead of hoping the agent follows through.",
5
5
  "license": "Apache-2.0",
6
6
  "author": "typicalday",
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "owenloop",
3
- "version": "0.5.20",
3
+ "version": "0.5.22",
4
4
  "description": "Claude Code driver for owenloop — cross-harness shift and conduct skills driven by the owenloop CLI, plus one hub control-plane MCP server backing an author skill and a fallback worker, for conducting and authoring workflows against your hosted owenloop server.",
5
5
  "author": {
6
6
  "name": "Typical Day"
@@ -7,7 +7,7 @@
7
7
  "mcp"
8
8
  ],
9
9
  "env": {
10
- "OWENLOOP_PLUGIN_VERSION": "0.5.20"
10
+ "OWENLOOP_PLUGIN_VERSION": "0.5.22"
11
11
  }
12
12
  }
13
13
  }
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "owenloop",
3
- "version": "0.5.20",
3
+ "version": "0.5.22",
4
4
  "description": "Codex plugin for the owenloop workflow engine.",
5
5
  "skills": "./skills/",
6
6
  "mcpServers": "./.mcp.json"
@@ -6,7 +6,7 @@
6
6
  "mcp"
7
7
  ],
8
8
  "env": {
9
- "OWENLOOP_PLUGIN_VERSION": "0.5.20"
9
+ "OWENLOOP_PLUGIN_VERSION": "0.5.22"
10
10
  },
11
11
  "env_vars": [
12
12
  "HOME",