just-vibe 0.7.0

package/plugins/just-vibe/skills/api-webhooks/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: api-webhooks
+description: "Implement signatures, retries, replay handling, and delivery tracking Use for authenticated durable event receipt; backend-jobs handles deferred processing."
+---
+
+# api-webhooks
+
+Implement signatures, retries, replay handling, and delivery tracking
+
+## Choose this workflow
+
+Use for authenticated durable event receipt; backend-jobs handles deferred processing.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [APIs methods](../../references/packs/api.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; inbound/outbound direction, provider contract, signing method, events, and environment.
+
+interface definitions, producer/consumer source, authentication model, versioning constraints, and isolated test endpoints. External API calls must respect environment, credentials, rate limits, and side-effect scope.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Verification, delivery/retry, replay handling, event ordering, and tracking for the specified integration.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Validate signatures against correct raw bytes, separate receipt from processing, implement durable deduplication, and test invalid, duplicate, delayed, and reordered messages.
+- Verify signatures using provider-specified raw bytes and time rules, persist receipt identity before acknowledgment and separate deduplication from business processing.
+
+## Decision branches
+
+- **When valid events arrive out of order or concurrently:** Apply version/ordering policy and durable effect deduplication rather than assuming arrival order.
+
+## Deliver and verify
+
+- Webhook implementation, configuration names, and recovery/verification evidence.
+- Receipt/processing state machine and invalid, replayed, duplicate and reordered checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Invalid signatures cause no business effect; retried events do not duplicate the intended effect.
+
+## Stop and recover
+
+- Never log signing secrets or send real business events without authorization. Provider uncertainty must be resolved before relying on delivery guarantees.
+
+## Example requests
+
+- **Normal (apply):** Implement signed webhook validation and durable duplicate handling in the sandbox.
+- **edge (apply):** Handle two concurrent copies of a signed payment event.
+- **blocked (inspect):** Review webhook handling without live signing keys or sending real business events.

package/plugins/just-vibe/skills/arch-boundaries/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: arch-boundaries
+description: "Find misplaced responsibilities, dependency cycles, and leaking abstractions Use to inspect responsibility and dependency violations; arch-feature designs a new feature's placement."
+---
+
+# arch-boundaries
+
+Find misplaced responsibilities, dependency cycles, and leaking abstractions
+
+## Choose this workflow
+
+Use to inspect responsibility and dependency violations; arch-feature designs a new feature's placement.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; modules/services and intended responsibility rules.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Coupling, cycles, ownership leaks, and misplaced responsibilities; no automatic service extraction.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inventory current responsibilities, data owners and dependency directions from composition roots, imports, schemas, network clients and deployment definitions. Mark inferred or inaccessible edges explicitly.
+- Trace a representative change and failure across the proposed boundary. Identify shared transactions, cycles, leaked internals and callers that would need coordinated release; file count alone is not evidence of a bad boundary.
+- Propose the smallest interface or ownership correction that reduces the demonstrated coupling. Specify allowed dependencies, compatibility, error semantics and enforcement in the existing build/test architecture.
+- Verify the boundary with a consumer-facing contract check and a forbidden-dependency example when appropriate. Estimate migration impact from actual consumers and keep unmeasured organizational benefits conditional.
+
+## Decision branches
+
+- **When a cycle is intentional and isolated behind an interface:** Assess change coupling and failure propagation before prescribing a split.
+
+## Deliver and verify
+
+- Boundary findings with examples and incremental repair options.
+- Concrete dependency paths, violated responsibility, demonstrated cost and incremental correction.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A dependency cycle has a concrete path; a justified shared utility is not rejected merely for having many callers.
+
+## Stop and recover
+
+- Distinguish organizational preference from demonstrated architectural cost. Missing ownership rules become questions, not invented mandates.
+
+## Example requests
+
+- **Normal (inspect):** Find responsibility leaks and dependency cycles in billing.
+- **edge (inspect):** Assess a shared utility with many callers but no ownership violation.
+- **blocked (inspect):** Review boundaries without an ownership map; identify assumptions requiring team input.

package/plugins/just-vibe/skills/arch-contracts/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: arch-contracts
+description: "Define interfaces and contracts between components or services Use for contracts across services or modules; api-openapi maintains a concrete HTTP schema."
+---
+
+# arch-contracts
+
+Define interfaces and contracts between components or services
+
+## Choose this workflow
+
+Use for contracts across services or modules; api-openapi maintains a concrete HTTP schema.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; producer/consumer boundaries, versions, and compatibility requirements.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Interface schemas, invariants, errors, ownership, and evolution; no endpoint implementation by default.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inventory actual consumers, compare current payloads and assumptions, define required/optional fields and errors, and design compatibility tests and deprecation steps.
+- Inventory writers/readers, nullable and optional semantics, version negotiation and error behavior; include independently deployed consumers.
+
+## Decision branches
+
+- **When old consumers reject unknown fields:** Treat even additive changes as potentially breaking and design a compatibility bridge.
+
+## Deliver and verify
+
+- Versioned contract proposal with examples and consumer obligations.
+- Contract examples, consumer compatibility matrix and deprecation gates.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Old consumers handle an additive field; a removed required field is identified as breaking.
+
+## Stop and recover
+
+- Do not infer all consumers from one repository. Unknown consumers require a compatibility-preserving assumption or explicit decision.
+
+## Example requests
+
+- **Normal (plan):** Define a versioned order-created contract that existing consumers can still read.
+- **edge (plan):** Evolve an event field while an offline consumer remains on an old version.
+- **blocked (inspect):** Review a contract without a complete consumer inventory; avoid universal compatibility claims.

package/plugins/just-vibe/skills/arch-event-flow/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: arch-event-flow
+description: "Design event delivery, retries, ordering, and failure handling Use for asynchronous consistency and delivery design; backend-jobs implements worker mechanics."
+---
+
+# arch-event-flow
+
+Design event delivery, retries, ordering, and failure handling
+
+## Choose this workflow
+
+Use for asynchronous consistency and delivery design; backend-jobs implements worker mechanics.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; event source, consumers, delivery guarantees, and failure requirements.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Event ownership, ordering, deduplication, retries, dead letters, and replay.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Trace transaction boundaries, identify loss/duplicate windows, specify identifiers and schemas, and define recovery and observability for each failure point.
+- Draw the write/commit/publish/ack sequence and place a crash between each pair; define replay identity and effect ownership.
+
+## Decision branches
+
+- **When database commit and broker publish are separate:** Compare a transactional outbox or explicit reconciliation with the actual loss window.
+
+## Deliver and verify
+
+- Event sequence diagram, delivery contract, failure matrix, and validation scenarios.
+- Failure-point table covering loss, duplicate, reordering, poison messages and recovery.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Duplicate and out-of-order deliveries have defined outcomes; a producer crash between database and broker operations is addressed.
+
+## Stop and recover
+
+- Do not promise exactly-once effects without a concrete consistency mechanism. Avoid choosing infrastructure without throughput and operational constraints.
+
+## Example requests
+
+- **Normal (plan):** Plan webhook-to-ledger processing with duplicate and reordered events.
+- **edge (plan):** Design order events with duplicate delivery and a producer crash after commit.
+- **blocked (inspect):** Assess event flow when broker guarantees are unknown; keep guarantees conditional.

package/plugins/just-vibe/skills/arch-feature/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: arch-feature
+description: "Design where a feature belongs within the existing architecture Use to place an accepted feature within a system; spec resolves unclear product behavior."
+---
+
+# arch-feature
+
+Design where a feature belongs within the existing architecture
+
+## Choose this workflow
+
+Use to place an accepted feature within a system; spec resolves unclear product behavior.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; feature specification, current architecture, and scale/compatibility constraints.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Placement of one feature across modules, services, storage, and interfaces.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Translate acceptance criteria and quality constraints into responsibilities, data ownership and interfaces. Trace an existing normal and failure path to locate the natural owner before proposing a new component.
+- Compare extending the current module, introducing an internal boundary and deploying a separate service. Assess data consistency, latency, independent rollout and operational ownership against demonstrated requirements.
+- Specify the chosen contract, compatibility window, failure/retry behavior and observability. Define who writes each datum and who reconciles partial effects; diagrams must distinguish observed code dependencies from proposed runtime edges.
+- Plan incremental implementation with a verification and recovery condition for each phase. Identify the smallest experiment that could overturn a material assumption before committing to an expensive boundary.
+
+## Decision branches
+
+- **When the feature spans two data owners:** Define consistency and failure semantics before selecting synchronous calls or events.
+
+## Deliver and verify
+
+- Requirement-to-owner map, alternatives and decisive evidence, target contracts/data ownership, phased implementation with checks and recovery limits.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Existing domain rules stay owned by one clear boundary; error and rollback paths are covered.
+
+## Stop and recover
+
+- Do not introduce a service or datastore solely for stylistic separation. Flag decisions requiring workload or ownership information.
+
+## Example requests
+
+- **Normal (plan):** Design where organization invitations fit in the existing architecture.
+- **edge (plan):** Design a feature that updates billing and access without a distributed transaction.
+- **blocked (inspect):** Plan placement while an external consumer contract is unavailable.

package/plugins/just-vibe/skills/arch-map/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: arch-map
+description: "Map services, packages, data stores, external dependencies, and relationships Use for deployed service/store topology; map covers repository modules."
+---
+
+# arch-map
+
+Map services, packages, data stores, external dependencies, and relationships
+
+## Choose this workflow
+
+Use for deployed service/store topology; map covers repository modules.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; system boundary, services/environments, and desired detail.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Existing services, stores, deployment units, trust boundaries, and external dependencies.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Reconcile source, deployment configuration, and documentation; identify ownership and protocols; trace a representative request and background process; label inferred edges.
+- Trace one request and one background operation, marking process, network, ownership and trust boundaries independently.
+
+## Decision branches
+
+- **When documentation disagrees with deployment configuration:** Show both claims with evidence dates and leave live topology unconfirmed without observations.
+
+## Deliver and verify
+
+- System diagram, component inventory, data/control flows, and evidence gaps.
+- Nodes/edges with protocol, owner, data classification and evidence confidence.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A shared database dependency appears even without source imports; a documented but undeployed service is marked uncertain.
+
+## Stop and recover
+
+- Do not describe a static diagram as proof of live topology. Missing infrastructure access limits deployment conclusions.
+
+## Example requests
+
+- **Normal (inspect):** Map our web app, workers, shared database, and external payment service.
+- **edge (inspect):** Map two services sharing a database but no source imports.
+- **blocked (inspect):** Map supplied manifests without infrastructure access; distinguish intended from observed deployment.

package/plugins/just-vibe/skills/arch-modernize/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: arch-modernize
+description: "Plan an incremental transition to a target architecture Use for staged architectural transition; refactor handles an internal structural change."
+---
+
+# arch-modernize
+
+Plan an incremental transition to a target architecture
+
+## Choose this workflow
+
+Use for staged architectural transition; refactor handles an internal structural change.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; current/target architecture, constraints, business continuity needs, and migration horizon.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Incremental modernization and transitional operation, not immediate replacement.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inventory dependencies, find separable seams, sequence compatibility layers and data movement, define parity checks, and set retirement criteria.
+- Identify a seam with separable traffic and data ownership, define coexistence checks and retirement evidence before replacing it.
+
+## Decision branches
+
+- **When old and new systems write the same records:** Specify source of truth, conflict handling and reconciliation before dual operation.
+
+## Deliver and verify
+
+- Phased migration architecture, coexistence plan, risks, and recovery checkpoints.
+- Phase-by-phase working state, cutover conditions and irreversible boundaries.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Each phase leaves a working system; old components are retired only after dependent traffic and data ownership move.
+
+## Stop and recover
+
+- Do not assume a big-bang rewrite is necessary. Flag irreversible transitions and missing operational ownership.
+
+## Example requests
+
+- **Normal (plan):** Plan an incremental extraction of billing while the old app keeps running.
+- **edge (plan):** Modernize a monolith while old reports still query its database.
+- **blocked (inspect):** Plan modernization without dependency ownership; list blocking unknowns by phase.

package/plugins/just-vibe/skills/arch-scale/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: arch-scale
+description: "Identify bottlenecks for a specified workload and growth scenario Use for workload-driven capacity design; perf measures and repairs a specific bottleneck."
+---
+
+# arch-scale
+
+Identify bottlenecks for a specified workload and growth scenario
+
+## Choose this workflow
+
+Use for workload-driven capacity design; perf measures and repairs a specific bottleneck.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; workload shape, expected growth, SLOs, current metrics, and resource limits.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Capacity constraints and targeted scaling strategy; no speculative whole-system rewrite.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- State workload shape, service objectives and measured constraints: arrival rate, service time distribution, concurrency, queue age and resource saturation. Separate observed production data from assumptions or synthetic samples.
+- Locate the limiting serial/shared boundary before recommending replicas, caching, queues or extraction. Model steady-state and burst behavior, failure recovery and downstream limits with explicit units.
+- Compare options against the bottleneck and consistency requirements. Define admission control/backpressure and degradation before adding unbounded concurrency; scaling callers can overload the shared dependency.
+- Propose a bounded measurement or authorized load experiment with rejecting observations and recovery. Report the capacity range established by evidence and what remains unknown; do not invent traffic or throughput.
+
+## Decision branches
+
+- **When a shared database or serialized step dominates:** Quantify that constraint before recommending application replicas or new services.
+
+## Deliver and verify
+
+- Bottleneck model, assumptions, capacity experiments, scaling sequence, and cost factors.
+- Assumptions, limiting resource, incremental options and a bounded benchmark plan.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A serialized database operation is not solved by app replicas alone; estimates identify their workload assumptions.
+
+## Stop and recover
+
+- No invented capacity numbers or automatic provisioning. Missing measurements yield an instrumentation/benchmark plan first.
+
+## Example requests
+
+- **Normal (plan):** Plan capacity experiments for a tenfold increase in checkout traffic.
+- **edge (plan):** Plan growth for a service bottlenecked by a serialized inventory update.
+- **blocked (inspect):** Assess scale without production metrics; avoid invented throughput estimates.

package/plugins/just-vibe/skills/arch-tenancy/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: arch-tenancy
+description: "Evaluate tenant isolation across authentication, storage, queries, and jobs Use for system-wide tenant isolation; backend-permissions handles individual application checks."
+---
+
+# arch-tenancy
+
+Evaluate tenant isolation across authentication, storage, queries, and jobs
+
+## Choose this workflow
+
+Use for system-wide tenant isolation; backend-permissions handles individual application checks.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Architecture methods](../../references/packs/architecture.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; tenant model, resource types, membership rules, and access boundaries.
+
+readable source, infrastructure/configuration definitions, and any supplied system documentation. Runtime telemetry is optional evidence, never assumed available. Architecture proposals remain plans until implementation is requested.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Tenant identity propagation across APIs, storage, caches, jobs, exports, and support operations.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Map tenant ownership, follow identity through every boundary, inspect membership changes and shared resources, and identify missing isolation checks.
+- Follow tenant identity through API, database role, cache key, queue payload, file storage and support/admin paths.
+
+## Decision branches
+
+- **When an identity belongs to several organizations:** Separate membership from selected-tenant authorization at each effect boundary.
+
+## Deliver and verify
+
+- Isolation map, risk findings, and proposed negative tests or migration design.
+- Resource ownership and propagation matrix with concrete bypass candidates.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Background jobs preserve tenant identity; multi-organization users cannot access an unselected unauthorized organization.
+
+## Stop and recover
+
+- Do not use real cross-tenant data for probing. Policy ambiguity must be resolved before implementing access changes.
+
+## Example requests
+
+- **Normal (inspect):** Audit organization isolation across caches, jobs, APIs, and exports.
+- **edge (inspect):** Review multi-organization users and background exports.
+- **blocked (inspect):** Inspect tenancy without authorized test identities; use source and synthetic fixtures only.

package/plugins/just-vibe/skills/auto/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: auto
+description: "Use the goal and project context to select, execute, and verify appropriate workflows Use to complete a bounded multi-step goal across workflows; direct commands are preferable for one clear operation."
+---
+
+# auto
+
+Use the goal and project context to select, execute, and verify appropriate workflows
+
+## Choose this workflow
+
+Use to complete a bounded multi-step goal across workflows; direct commands are preferable for one clear operation.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply within the requested goal; objective plus arbitrary constraints, references, environment, and optional mode/budget. Requires available workflow discovery.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Smallest useful sequence completing that goal; no extra product work or authority expansion.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+1. Preserve the complete brief, project, scope, constraints, success criteria and current task profile. Inspect only the context needed to choose the next useful workflow. Honor an explicit profile pin.
+2. Choose quick or tracked execution using the daily-workflows guide. A small local fix, explanation or review can stay in conversation context without JSON session calls. The route utility suggests candidates, reasons and a strategy; the host resolves actual intent and effects.
+3. For quick work, read the selected skill and relevant scenario guide, perform the bounded task, verify its actual output and summarize the result. Preserve user constraints and report unavailable evidence. Do not add a planning-only stop to a clear implementation request.
+4. Use tracked execution for dependent stages, repeated recovery, saved continuation, external mutations or requested detailed records. Create a run through session create and use session start/record/finish around meaningful stages; use session amend for additional effects and session supersede for evidence-backed alternatives.
+5. If quick work grows, carry the original brief, completed work, observations, selected profile and consumed budget into tracked context. Record remaining stages; never fabricate earlier validated transitions or restart a user limit.
+6. Reconcile uncertain external effects before retrying. Keep failures and stop within the applicable stage/attempt/time budget. Finish only when original success conditions are supported; report partial or blocked results plainly.
+
+Task-specific method: Choose the smallest useful workflow and proportionate execution path. Complete authorized work with carried context, meaningful verification and a clear result.
+
+## Read when relevant
+
+- Choosing quick versus tracked work: [Daily workflow paths](../../references/daily-workflows.md).
+
+## Decision branches
+
+- **When one bounded local workflow is sufficient:** Use the quick path; keep essential context and evidence in conversation without formal stage bookkeeping.
+- **When dependencies, repeated recovery, continuation or external effects need tracking:** Use the existing validated session operations; retain earlier evidence and consumed limits when escalating.
+
+## Deliver and verify
+
+- Goal result, selected workflows, verification, and any incomplete steps.
+- Original criteria mapped to evidence, stage history, supersessions and remaining work.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A no-dependencies constraint survives every stage; missing prerequisites trigger a valid alternative or blocker, not invented execution.
+
+## Stop and recover
+
+- Tracked defaults remain eight stages, three attempts per stage and sixty minutes. Quick work honors user limits and switches to tracked handling when needed; neither path permits recursive auto/do or unrequested external effects.
+
+## Example requests
+
+- **Normal (apply):** Fix the checkout bug, add meaningful regression coverage, and verify; no new dependencies.
+- **edge (apply):** Finish a task using local artifacts after a remote diagnostic stage is blocked.
+- **blocked (inspect):** Inspect a route with missing access; do not invent credentials or claim blocked actions ran.

package/plugins/just-vibe/skills/automate/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: automate
+description: "Turn a repetitive process into a script or workflow Use for a repeatable local workflow; a scheduled service requires an actual separately scoped runtime."
+---
+
+# automate
+
+Turn a repetitive process into a script or workflow
+
+## Choose this workflow
+
+Use for a repeatable local workflow; a scheduled service requires an actual separately scoped runtime.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; repeated process, trigger, inputs, destinations, and error expectations.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Script or workflow implementing the process; registering schedules or enabling external triggers requires that requested action.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Observe current steps, isolate deterministic operations, validate inputs, implement failure reporting and repeat behavior, and test with controlled fixtures.
+- Define inputs, output ownership, locking and idempotency; produce meaningful exit statuses and rehearse interruption between durable steps.
+
+## Decision branches
+
+- **When a previous run left partial output:** Detect its identity and either resume or stop with a reconciliation instruction; never treat partial output as success.
+
+## Deliver and verify
+
+- Runnable automation, usage, required permissions, and execution evidence.
+- Runnable entry point, input contract, repeat-run policy and failure/exit behavior.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Repeated execution has deliberate duplicate handling; partial failure exits clearly and preserves recoverable state.
+
+## Stop and recover
+
+- Do not embed credentials, create unsolicited scheduled jobs, or automate ambiguous human decisions without an explicit rule.
+
+## Example requests
+
+- **Normal (apply):** Create a repeatable local script to validate our release artifacts.
+- **edge (apply):** Automate report generation when an earlier run left half the output.
+- **blocked (inspect):** Inspect automation requirements without installing a scheduler or contacting services.